Type aliases
AcceptedPredicateTypes
AcceptedPredicateTypes: function | string | Array<string>
ActionCache
ActionCache: object & object | object
ActionCacheQueueItem
ActionCacheQueueItem: object
Type declaration
-
-
allowErrors: boolean
-
allowPending: boolean
-
-
-
invalidate: boolean
-
isContextDependency: boolean
-
isDependencyOf: CachedAction | undefined
-
visitedDependants: HashSet | undefined
-
visitedDependencies: HashSet | undefined
AddItemAttableGraphNode
Add
ItemAttableGraphNode: DynamicGraphNode<T, P, S, D, V, "addItemAt", AddItemAtOperation, AddItemAttableNodeType<T, P, S, D, V>>
AddItemAttableNodeDefinition
Add
ItemAttableNodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "addItemAt", AddItemAtOperation, AddItemAttableNodeType<T, P, S, D, V>>
BranchDefinition
BranchDefinition: object
Type declaration
-
-
-
param: string | undefined
CachedActionId
CachedActionId: number
CallArgumentMap
CallArgumentMap: object
CallableGraphNode
Callable
GraphNode: DynamicGraphNode<T, P, S, D, V, "call", CallOperation, CallableNodeType<T, P, S, D, V>>
CallableNodeDefinition
Callable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "call", CallOperation, CallableNodeType<T, P, S, D, V>>
Callback
Callback: function
Type declaration
-
- (err: any, response: T, body: any): void
-
Parameters
-
err: any
-
response: T
-
body: any
Returns void
ClearableGraphNode
Clearable
GraphNode: DynamicGraphNode<T, P, S, D, V, "clear", ClearOperation, ClearableNodeType<T, P, S, D, V>>
ClearableNodeDefinition
Clearable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "clear", ClearOperation, ClearableNodeType<T, P, S, D, V>>
ContainerGraphNode
Container
GraphNode: DynamicGraphNode<T, P, S, D, V, "getChild", GetChildOperation, ContainerNodeType<T, P, S, D, V>>
ContainerNodeDefinition
Container
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "getChild", GetChildOperation, ContainerNodeType<T, P, S, D, V>>
ContainsableGraphNode
Containsable
GraphNode: DynamicGraphNode<T, P, S, D, V, "contains", ContainsOperation, ContainsableNodeType<T, P, S, D, V>>
ContainsableNodeDefinition
Containsable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "contains", ContainsOperation, ContainsableNodeType<T, P, S, D, V>>
ContextId
ContextId: string
ContextName
ContextName: string
ContextValues
ContextValues: object
ContextValuesDefinitions
ContextValuesDefinitions: object
ContextWithPathKey
Context
WithPathKey: Context & object
DeferNodeFallbackGenerator
DeferNodeFallbackGenerator: function
DisposeCallback
DisposeCallback: function
DisposeCallback
DisposeCallback: function
DisposeRequest
DisposeRequest: function
DynamicNodeType
Dynamic
NodeType: StatelessNodeType<T, P, V, M, O> | StatefulNodeType<T, P, S, D, V, M, O>
EmitterCallback
EmitterCallback: function
ErrorFallbackGenerator
ErrorFallbackGenerator: function
EvaluableGraphNode
Evaluable
GraphNode: DynamicGraphNode<T, P, S, D, V, "evaluate", EvaluateOperation, EvaluableNodeType<T, P, S, D, V>>
EvaluableNodeDefinition
Evaluable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "evaluate", EvaluateOperation, EvaluableNodeType<T, P, S, D, V>>
EventRedispatcher
EventRedispatcher: function
ExclusiveSliceBounds
ExclusiveSliceBounds: object
FieldSetDefinition
FieldSetDefinition: object
GetterFactory
GetterFactory: function
GraphNodeWithIsPending
Graph
NodeWithIsPending: DynamicGraphNode<T, P, S, D, V, "isPending", IsPendingOperation, NodeTypeWithIsPending<T, P, S, D, V>>
GraphNodeWithIsUpdating
Graph
NodeWithIsUpdating: DynamicGraphNode<T, P, S, D, V, "isUpdating", IsUpdatingOperation, NodeTypeWithIsUpdating<T, P, S, D, V>>
GraphNodeWithRemoveItem
Graph
NodeWithRemoveItem: DynamicGraphNode<T, P, S, D, V, "removeItem", RemoveItemOperation, NodeTypeWithRemoveItem<T, P, S, D, V>>
HashSet
HashSet: Set<string>
HistoryWithId
HistoryWithId: History & object
InclusiveSliceBounds
InclusiveSliceBounds: object
InitableGraphNode
Initable
GraphNode: DynamicGraphNode<T, P, S, D, V, "init", InitOperation, InitableNodeType<T, P, S, D, V>>
InitableNodeDefinition
Initable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "init", InitOperation, InitableNodeType<T, P, S, D, V>>
InvalidTypeErrorOptions
InvalidTypeErrorOptions: object
Type declaration
-
Optional expected?: any | Array<any>
-
received: any
InvalidateOnNodeCallback
InvalidateOnNodeCallback: function
IterableGraphNode
Iterable
GraphNode: DynamicGraphNode<T, P, S, D, V, "iterate", IterateOperation, IterableNodeType<T, P, S, D, V>>
IterableNodeDefinition
Iterable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "iterate", IterateOperation, IterableNodeType<T, P, S, D, V>>
KeyMatcher
KeyMatcher: function
Type declaration
-
-
Parameters
Returns boolean
LengthtableGraphNode
Lengthtable
GraphNode: DynamicGraphNode<T, P, S, D, V, "length", LengthOperation, LengthtableNodeType<T, P, S, D, V>>
LengthtableNodeDefinition
Lengthtable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "length", LengthOperation, LengthtableNodeType<T, P, S, D, V>>
ListGraphNode
List
GraphNode: DynamicGraphNode<T, P, S, D, V, "getItems", GetItemsOperation, ListNodeType<T, P, S, D, V>>
ListNodeDefinition
List
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "getItems", GetItemsOperation, ListNodeType<T, P, S, D, V>>
LocationParamsEncoding
LocationParamsEncoding: "base64" | "json"
LogSink
LogSink: function
Type declaration
-
- (...args: Array<any>): void
MiddlewareTransformer
MiddlewareTransformer: function
ModuleDependencies
ModuleDependencies: object
ModuleFactory
ModuleFactory: function
ModuleRequirements
ModuleRequirements: object
MusterEventName
MusterEventName: string
MusterEventPayload
MusterEventPayload: any
MusterOperationDefinition
MusterTypeMap
MusterTypeMap: object
MusterTypeName
MusterTypeName: string
NamedFnArgs
NamedFnArgs: object
NodeData
NodeData: object
NodeDefinitionCallback
NodeDefinitionCallback: function
NodeDefinitionWithIsPending
Node
DefinitionWithIsPending: DynamicNodeDefinition<T, P, S, D, V, "isPending", IsPendingOperation, NodeTypeWithIsPending<T, P, S, D, V>>
NodeDefinitionWithIsUpdating
Node
DefinitionWithIsUpdating: DynamicNodeDefinition<T, P, S, D, V, "isUpdating", IsUpdatingOperation, NodeTypeWithIsUpdating<T, P, S, D, V>>
NodeDefinitionWithRemoveItem
Node
DefinitionWithRemoveItem: DynamicNodeDefinition<T, P, S, D, V, "removeItem", RemoveItemOperation, NodeTypeWithRemoveItem<T, P, S, D, V>>
NodeLikeCallArgumentArray
NodeLikeCallArgumentMap
NodeLikeCallArgumentMap: object
NodeName
NodeName: string
NodeProperties
NodeProperties: object
NodeTransformer
NodeTransformer: function
NodeTypeMap
NodeTypeMap: object
OnNodeCallback
OnNodeCallback: function
OperationFactory
OperationFactory: function
OperationHandler
Operation
Handler: StatelessOperationHandler<T, P, V, M, O> | StatefulOperationHandler<T, P, S, D, V, M, O>
OperationHandlerDefinition
OperationId
OperationId: string
OperationName
OperationName: string
OperationProperties
OperationProperties: object
OperationTypeMap
OperationTypeMap: object
PendingFallbackGenerator
PendingFallbackGenerator: function
PoptableGraphNode
Poptable
GraphNode: DynamicGraphNode<T, P, S, D, V, "pop", PopOperation, PoptableNodeType<T, P, S, D, V>>
PoptableNodeDefinition
Poptable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "pop", PopOperation, PoptableNodeType<T, P, S, D, V>>
PushtableGraphNode
Pushtable
GraphNode: DynamicGraphNode<T, P, S, D, V, "push", PushOperation, PushtableNodeType<T, P, S, D, V>>
PushtableNodeDefinition
Pushtable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "push", PushOperation, PushtableNodeType<T, P, S, D, V>>
QueriesSnapshot
QueriesSnapshot: object
QueryPartCallback
QueryPartCallback: function
QuerySetCallback
QuerySetCallback: function
QuerySetChildWithPath
QuerySetChildWithPath: object
RelativeSliceBounds
RelativeSliceBounds: object
RemoveItemAttableGraphNode
Remove
ItemAttableGraphNode: DynamicGraphNode<T, P, S, D, V, "removeItemAt", RemoveItemAtOperation, RemoveItemAttableNodeType<T, P, S, D, V>>
RemoveItemAttableNodeDefinition
Remove
ItemAttableNodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "removeItemAt", RemoveItemAtOperation, RemoveItemAttableNodeType<T, P, S, D, V>>
RemoveItemAttableNodeType
RequestGraphNode
Request
GraphNode: DynamicGraphNode<T, P, S, D, V, "request", RequestOperation, RequestNodeType<T, P, S, D, V>>
RequestMetadata
RequestMetadata: object
RequestNodeDefinition
Request
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "request", RequestOperation, RequestNodeType<T, P, S, D, V>>
ResettableGraphNode
Resettable
GraphNode: DynamicGraphNode<T, P, S, D, V, "reset", ResetOperation, ResettableNodeType<T, P, S, D, V>>
ResettableNodeDefinition
Resettable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "reset", ResetOperation, ResettableNodeType<T, P, S, D, V>>
ResolvableGraphNode
Resolvable
GraphNode: DynamicGraphNode<T, P, S, D, V, "resolve", ResolveOperation, ResolvableNodeType<T, P, S, D, V>>
ResolvableNodeDefinition
Resolvable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "resolve", ResolveOperation, ResolvableNodeType<T, P, S, D, V>>
ResponseAssembler
ResponseAssembler: function
ResponseFactory
ResponseFactory: function
ResponsePartAssembler
ResponsePartAssembler: function
ResponseTransformer
ResponseTransformer: function
ResultableGraphNode
Resultable
GraphNode: DynamicGraphNode<T, P, S, D, V, "result", ResultOperation<any>, ResultableNodeType<T, P, S, D, V>>
ResultableNodeDefinition
Resultable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "result", ResultOperation<any>, ResultableNodeType<T, P, S, D, V>>
SchedulerFactory
SchedulerFactory: function
SerializableQuerySetChild
SerializedActionCache
SerializedActionCache: object & object | object
SerializedGraphOperation
SerializedGraphOperation: object
Type declaration
-
$operation: O["name"]
-
data: P
-
id: string
SerializedMusterTypeData
SerializedMusterTypeData: any
SerializedNodeDefinition
SerializedNodeDefinition: object
SerializedNodeProperties
SerializedNodeProperties: any
SerializedNodeType
SerializedNodeType: object
Type declaration
-
operations: Array<string>
SerializedNodeTypesMap
SerializedNodeTypesMap: object
SerializedOperationProperties
SerializedOperationProperties: any
SerializedPrimitive
SerializedPrimitive: string | number | boolean | null | undefined
SerializedSubscription
SerializedSubscription: object
SettableGraphNode
Settable
GraphNode: DynamicGraphNode<T, P, S, D, V, "set", SetOperation, SettableNodeType<T, P, S, D, V>>
SettableNodeDefinition
Settable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "set", SetOperation, SettableNodeType<T, P, S, D, V>>
SetterFactory
SetterFactory: function
ShapeFields
ShapeFields: object
ShifttableGraphNode
Shifttable
GraphNode: DynamicGraphNode<T, P, S, D, V, "shift", ShiftOperation, ShifttableNodeType<T, P, S, D, V>>
ShifttableNodeDefinition
Shifttable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "shift", ShiftOperation, ShifttableNodeType<T, P, S, D, V>>
SortValue
SortValue: null | undefined | boolean | string | number | Date
SteppableGraphNode
Steppable
GraphNode: DynamicGraphNode<T, P, S, D, V, "step", StepOperation<any>, SteppableNodeType<T, P, S, D, V>>
SteppableNodeDefinition
Steppable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "step", StepOperation<any>, SteppableNodeType<T, P, S, D, V>>
StoreSubscribe
StoreSubscribe: function
StreamFactory
StreamFactory: function
StreamUpdateCallback
StreamUpdateCallback: function
SupportsRemoveItemsGraphNode
Supports
RemoveItemsGraphNode: DynamicGraphNode<T, P, S, D, V, "removeItems", RemoveItemsOperation, SupportsRemoveItemsNodeType<T, P, S, D, V>>
SupportsRemoveItemsNodeDefinition
Supports
RemoveItemsNodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "removeItems", RemoveItemsOperation, SupportsRemoveItemsNodeType<T, P, S, D, V>>
SupportsRemoveItemsNodeType
TransformerGraphNode
Transformer
GraphNode: DynamicGraphNode<T, P, S, D, V, "transformItems", TransformItemsOperation, TransformerNodeType<T, P, S, D, V>>
TransformerNodeDefinition
TransformerNodeDefinition
Transformer
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "transformItems", TransformItemsOperation, TransformerNodeType<T, P, S, D, V>>
UnshifttableGraphNode
Unshifttable
GraphNode: DynamicGraphNode<T, P, S, D, V, "unshift", UnshiftOperation, UnshifttableNodeType<T, P, S, D, V>>
UnshifttableNodeDefinition
Unshifttable
NodeDefinition: DynamicNodeDefinition<T, P, S, D, V, "unshift", UnshiftOperation, UnshifttableNodeType<T, P, S, D, V>>
UnsubscribeCallback
UnsubscribeCallback: function
UpdateCallback
UpdateCallback: function
UpdateCallback
UpdateCallback: function
ValueStreamFactory
ValueStreamFactory: function
ValueUpdater
ValueUpdater: Partial<object> | function
XhrResult
XhrResult: object | object
Variables
Const ActionNodeType
Action
NodeType: StatelessNodeType<"action", ActionNodeProperties> = createNodeType<'action',ActionNodeProperties>('action', {serialize: false,deserialize: false,shape: {body: types.saveHash(types.func),},operations: {call: {cacheable: false,getDependencies(properties: ActionNodeProperties,operation: CallOperation,): Array<NodeDependency> {const { args } = operation.properties;if (!args) return [];if (isCallArgumentArray(args)) {return args.map((arg) => ({target: arg,until: untilIsDataNode,once: true,}));}return Object.keys(args).map((name) => ({target: args[name],until: untilIsDataNode,once: true,}));},run(node: ActionNode,operation: CallOperation,argValues: Array<DataNode>,): GraphNode | NodeDefinition {const { body } = node.definition.properties;const { args } = operation.properties;const unwrappedArgs = argValues.map((argValue) => valueOf(argValue));let result: any;if (!args) {result = body();} else if (isCallArgumentArray(args)) {// Handle array of argumentsresult = body(...unwrappedArgs);} else {// Handle named argumentsconst argNames = Object.keys(args);result = body(fromPairs(zip(argNames, unwrappedArgs)));}if (isProxiedNode(result)) {return getProxiedNodeValue(result);}if (isGraphNode(result)) {return result;}if (isNodeDefinition(result)) {return withScopeFrom(node, result);}if (isGenerator(result)) {const generatorResult = stepNext(result, []);return isGraphNode(generatorResult)? generatorResult: withScopeFrom(node, generatorResult);}return withScopeFrom(node, value(result));},},},})
Const AddItemAtNodeType
Add
ItemAtNodeType: StatefulNodeType<"add-item-at", AddItemAtNodeProperties, AddItemAtNodeState, __type> = createNodeType<'add-item-at', AddItemAtNodeProperties, AddItemAtNodeState, {}>('add-item-at', {shape: {index: graphTypes.nodeDefinition,item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, item: NodeDefinition, index: number) =>createGraphAction(target, addItemAtOperation(item, index)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, index }: AddItemAtNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsAddItemAtOperation,},{target: index,until: untilIntegerValueIndex,},];},run(node: AddItemAtNode,options: never,[target, index]: [GraphNode, ValueNode<number>],context: never,state: AddItemAtNodeState,): GraphAction {const { item } = node.definition.properties;return state.memoized(target, item, index.definition.properties.value);},},},})
Const AddItemAtOperationType
Add
ItemAtOperationType: OperationType<"addItemAt", AddItemAtProperties> = createOperationType<'addItemAt', AddItemAtProperties>('addItemAt', {cacheable: false,shape: {index: types.number,value: graphTypes.nodeDefinition,},})
Const AddNodeType
Add
NodeType: StatelessNodeType<"add", AddNodeProperties> = createNodeType<'add',AddNodeProperties>('add', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: AddNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(AddNodeType, 'operand'),}));},run(node: AddNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total + value, 0));},},},})
Const AndNodeType
And
NodeType: StatelessNodeType<"and", AndNodeProperties> = createNodeType<'and',AndNodeProperties>('and', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: AndNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('And node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: AndNode, options: never, operands: Array<ValueNode<any>>): NodeDefinition {return value(operands.every((operand) => Boolean(operand.definition.properties.value)));},},},})
Const ApplyNodeType
Apply
NodeType: StatelessNodeType<"apply", ApplyNodeProperties> = createNodeType<'apply',ApplyNodeProperties>('apply', {shape: {target: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),args: types.oneOfType([types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),]),},operations: {evaluate: {getDependencies({ target }: ApplyNodeProperties): [NodeDependency] {return [{target,until: untilSupportsCallOperation,},];},run(node: ApplyNode, options: never, [subjectNode]: [CallableGraphNode]): GraphAction {const { args } = node.definition.properties;let argNodes: any;if (isCallArgumentArray(args)) {argNodes = args.map((arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg)));} else {argNodes = mapValues(args, (arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg)));}return createGraphAction(subjectNode, callOperation(argNodes));},},},})
Const ApplyTransformsNodeType
Apply
TransformsNodeType: StatelessNodeType<"applyTransforms", ApplyTransformsNodeProperties> = createNodeType<'applyTransforms', ApplyTransformsNodeProperties>('applyTransforms', {shape: {target: graphTypes.nodeDefinition,transforms: types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),},operations: {getItems: {getDependencies({ target }: ApplyTransformsNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsGetItemOperation,},];},run(node: ApplyTransformsNode,operation: GetItemsOperation,[source]: [GraphNode],): GraphAction {const { transforms } = node.definition.properties;const scopedTransforms = [...transforms, ...operation.properties.transforms].map((transform) => (isNodeDefinition(transform) ? withScopeFrom(node, transform) : transform),);return createGraphAction(source, getItemsOperation(scopedTransforms));},},},})
Const ArithmeticNodeTypes
Arithmetic
NodeTypes: Array<NodeType> = [AddNodeType,CeilNodeType,ClampNodeType,DivideNodeType,FloorNodeType,MaxNodeType,MinNodeType,ModNodeType,MultiplyNodeType,PowNodeType,RoundNodeType,SqrtNodeType,SubtractNodeType,]
Const ArrayListNodeType
Array
ListNodeType: StatefulNodeType<"arrayList", ArrayListNodeProperties, ArrayListNodeState, ArrayListNodeData> = createNodeType<'arrayList', ArrayListNodeProperties, ArrayListNodeState, ArrayListNodeData>('arrayList',{state: {items: types.optional(graphTypes.nodeDefinition),poppedItem: types.optional(graphTypes.graphNode),shiftedItem: types.optional(graphTypes.graphNode),unshiftedItem: types.optional(graphTypes.graphNode),removeItems: types.objectOf(graphTypes.nodeDefinition),},shape: {items: types.arrayOf(graphTypes.nodeDefinition),},getInitialState(): ArrayListNodeState {return {items: undefined,poppedItem: undefined,shiftedItem: undefined,unshiftedItem: undefined,removeItems: {},};},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,) {if (this.getState().items) return;this.retain();this.setState((state) => ({...state,items: nodeList(node.definition.properties.items.map((item) => withUniqueId(node, item))),}));},operations: {addItemAt: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: AddItemAtOperation,): void {const { index, value } = operation.properties;const clonedItems = this.getState().items!.properties.items.slice(0);const sanitizedIndex = Math.min(clonedItems.length - 1, index);clonedItems.splice(sanitizedIndex, 0, withUniqueId(node, value));this.setState((state) => ({...state,items: nodeList(clonedItems),}));},},clear: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,): void {this.setState((state) => ({...state,items: nodeList([]),}));},},evaluate: {run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): NodeDefinition {return state.items!;},},length: {run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): NodeDefinition {return value(state.items!.properties.items.length);},},contains: {run(node: ArrayListNode,operation: ContainsOperation,dependencies: Array<never>,contextDependencies: Array<never>,state: ArrayListNodeState,): NodeDefinition {const { item: otherItem, comparator } = operation.properties;return resolve(state.items!.properties.items.map((item) => ({target: apply([item, otherItem], comparator),until: untilBooleanValuePredicate,})),(results: Array<ValueNode<boolean>>) =>value(results.some((item) => item.definition.properties.value)),);},},pop: {cacheable: false,run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): GraphNode {return state.poppedItem!;},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,): void {const items = this.getState().items!.properties.items;if (items.length === 0) {this.setState((state) => ({...state,poppedItem: withScopeFrom(node, nil()),}));return;}const remaining = items.slice(0);const last = remaining.pop()!;this.setState((state) => ({...state,items: nodeList(remaining),poppedItem: last,}));},},push: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: PushOperation,): void {const { items } = this.getState().items!.properties;this.setState((state) => ({...state,items: nodeList([...items, withUniqueId(node, operation.properties.value)]),}));},},removeItem: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: RemoveItemOperation,): void {const { items } = this.getState().items!.properties;const clonedItems = items.slice(0);const itemIndex = clonedItems.findIndex((item) => item.definition.properties.id === operation.properties.id,);if (itemIndex === -1) return;clonedItems.splice(itemIndex, 1);this.setState((state) => ({...state,items: nodeList(clonedItems),}));},},removeItemAt: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: RemoveItemAtOperation,): void {const { index } = operation.properties;const { items } = this.getState().items!.properties;if (!Number.isInteger(index) || index < 0 || index > items.length - 1) return;this.setState((state) => ({...state,items: nodeList([...items.slice(0, operation.properties.index),...items.slice(operation.properties.index + 1),]),}));},},removeItems: {cacheable: false,run(node: ArrayListNode,operation: RemoveItemsOperation,dependencies: Array<never>,contextDependencies: Array<never>,state: ArrayListNodeState,): NodeDefinition {const { removeItems } = state;return removeItems[operation.id] || ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: RemoveItemsOperation,): void {const { predicate } = operation.properties;const { items } = this.getState().items!.properties;if (items.length === 0) {return;}this.setState((prevState) =>operation.id in prevState.removeItems? prevState: {...prevState,removeItems: {...prevState.removeItems,[operation.id]: resolve(items.map((item) => ({target: apply([item], predicate),until: untilBooleanValuePredicate,})),(processedResults: Array<ValueNode<boolean>>) => {this.setState((prevState) => {// If the array list has been mutated since this operation was subscribed, there// may now be some items which haven't been tested. These should NOT be removed.const { items: currentItems } = this.getState();const updatedItems = currentItems!.properties.items.filter((item, index) => {const processedItemIndex = items.findIndex((processedItem) => processedItem.id === item.id,);if (processedItemIndex === -1) {return true;}const result = processedResults[processedItemIndex];return !result.definition.properties.value;},);return {...prevState,items: nodeList(updatedItems),removeItems: omit(prevState.removeItems, operation.id),};});return ok();},),},},);},},shift: {cacheable: false,run(node: ArrayListNode,options: never,dependencies: Array<never>,context: Array<never>,state: ArrayListNodeState,): GraphNode {return state.shiftedItem!;},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,): void {const { items } = this.getState().items!.properties;if (!items || items.length === 0) {this.setState((state) => ({...state,shiftedItem: withScopeFrom(node, nil()),}));return;}const remaining = items.slice(0);const last = remaining.shift()!;this.setState((state) => ({...state,items: nodeList(remaining),shiftedItem: last,}));},},unshift: {cacheable: false,run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<ArrayListNodeState, ArrayListNodeData>,node: ArrayListNode,operation: UnshiftOperation,): void {const { items } = this.getState().items!.properties;this.setState((state) => ({...state,items: nodeList([withUniqueId(node, operation.properties.value), ...items]),}));},},},},)
Const ArrayNodeType
Array
NodeType: StatelessNodeType<"array", ArrayNodeProperties> = createNodeType<'array',ArrayNodeProperties>('array', {shape: {items: types.arrayOf(graphTypes.nodeDefinition),},operations: {getItems: {run(node: ArrayNode, operation: GetItemsOperation): NodeDefinition | GraphAction {const items = toGraphNodesWithIndices(node, node.definition.properties.items);const itemsNode = nodeList(items);return operation.properties.transforms.length === 0? itemsNode: createGraphAction(withScopeFrom(node, itemsNode), operation);},},iterate: {run(node: ArrayNode): NodeDefinition {const items = toGraphNodesWithIndices(node, node.definition.properties.items);if (items.length === 0) {return nil();}return iteratorResult(items[0], nodeList(items.slice(1)));},},length: {run(node: ArrayNode): NodeDefinition {return value(node.definition.properties.items.length);},},contains: {run(node: ArrayNode, operation: ContainsOperation): NodeDefinition {const items = toGraphNodesWithIndices(node, node.definition.properties.items);const { item: otherItem, comparator } = operation.properties;return resolve(items.map((item) => ({target: apply([item, otherItem], comparator),until: untilBooleanValueNodeItem,})),(results: Array<ValueNode<boolean>>) =>value(results.some((item) => item.definition.properties.value)),);},},},})
Const ArrayReducerNodeType
Array
ReducerNodeType: StatelessNodeType<"arrayReducer", ArrayReducerNodeProperties> = createNodeType('arrayReducer', {operations: {init: {run(): ValueNodeDefinition<ArrayReducerAccumulator> {return value([]);},},step: {run(node: ArrayReducerNode,operation: StepOperation<ArrayReducerAccumulator>,): ValueNodeDefinition<ArrayReducerAccumulator> {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {run(node: ArrayReducerNode,operation: ResultOperation<ArrayReducerAccumulator>,): ValueNodeDefinition<NodeListNodeDefinition> {return value(nodeList(operation.properties.acc));},},},})
Const BatchRequestsMiddlewareNodeType
Batch
RequestsMiddlewareNodeType: StatefulNodeType<"batch-requests-middleware", BatchRequestsMiddlewareNodeProperties, BatchRequestsMiddlewareNodeState, BatchRequestsMiddlewareNodeData> = createNodeType<'batch-requests-middleware',BatchRequestsMiddlewareNodeProperties,BatchRequestsMiddlewareNodeState,BatchRequestsMiddlewareNodeData>('batch-requests-middleware', {shape: {},state: {batcherResults: types.objectOf(graphTypes.nodeDefinition),},getInitialState() {return {batcherResults: {},};},onSubscribe() {this.setData({batchers: new Map(),});},onUnsubscribe() {const { batchers } = this.getData();if (!batchers) return;for (const batcher of batchers.values()) {batcher.dispose();}},operations: {request: {run(node: BatchRequestsMiddlewareNode,operation: RequestOperation,dependencies: never,context: never,state: BatchRequestsMiddlewareNodeState,): NodeDefinition | GraphNode {const { metadata, next, query } = operation.properties;if (!next) {return error('Missing `next` middleware.');}if (!isQuerySetNodeDefinition(query)) {return withScopeFrom(next, traverse(next.definition, requestOperation(query, metadata)));}return state.batcherResults[query.properties.root.id] || pending();},onSubscribe(this: NodeExecutionContext<BatchRequestsMiddlewareNodeState,BatchRequestsMiddlewareNodeData>,node: BatchRequestsMiddlewareNode,operation: RequestOperation,): void {const { metadata, next, query } = operation.properties;// Check if the query is of a supported type or the next middleware is undefinedif (!next || !isQuerySetNodeDefinition(query)) return;const batchers = this.getData().batchers!;const { children, root } = query.properties;let currentBatcher = batchers.get(root.id);if (!currentBatcher) {currentBatcher = new RequestBatcher((node, operation, callback) => node.scope.store.subscribe(node, operation, callback),next,root,(value) => {this.setState((state) => ({...state,batcherResults: {...state.batcherResults,[root.id]: value,},}));},);batchers.set(root.id, currentBatcher);}this.setState((state) => ({...state,batcherResults: omit(state.batcherResults, root.id),}));currentBatcher.setRequest(children as Array<SerializableQuerySetChild>, metadata);},onUnsubscribe(this: NodeExecutionContext<BatchRequestsMiddlewareNodeState,BatchRequestsMiddlewareNodeData>,node: BatchRequestsMiddlewareNode,operation: RequestOperation,): void {const { query } = operation.properties;if (!isQuerySetNodeDefinition(query)) return;const { root } = query.properties;this.setState((state) => ({...state,batcherResults: omit(state.batcherResults, root.id),}));},},},})
Const BrowserNodeTypes
Browser
NodeTypes: Array<NodeType> = [LocationNodeType,LocationDataNodeType,LocationPathNodeType,]
Const CACHED_INSTANCES
CACHED_
INSTANCES: GraphOperation<string, ResolveProperties, ResolveProperties, OperationType<"resolve", ResolveProperties, ResolveProperties>>[] = [// TODO: Cleanup the `as ResolveProperties`createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: false,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: false,acceptNil: true,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: true,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: false,allowPending: true,acceptNil: true,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: false,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: false,acceptNil: true,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: true,acceptNil: false,} as ResolveProperties),createGraphOperation(ResolveOperationType, {until: undefined,allowErrors: true,allowPending: true,acceptNil: true,} as ResolveProperties),]
Const CONTEXT
CONTEXT: unique symbol = Symbol.for('muster::CONTEXT')
Const CallNodeType
Call
NodeType: StatefulNodeType<"call", CallNodeProperties, CallNodeState, CallNodeData> = createNodeType<'call', CallNodeProperties, CallNodeState, CallNodeData>('call', {shape: {target: graphTypes.nodeDefinition,args: types.optional(types.oneOfType([types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),]),),},state: {currentValue: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {cacheable: false,run(node: CallNode,options: never,dependencies: never,context: never,state: CallNodeState,): GraphNode | NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<CallNodeState, CallNodeData>, node: CallNode): void {const { target } = node.definition.properties;const updateState = ([result]: [GraphNode]) => {this.setState({ currentValue: result });return result;};this.setState({currentValue: resolve([{ target, until: untilSupportsCallOperation }], ([targetNode]) => {const { args } = node.definition.properties;let argNodes: CallArgumentMap | CallArgumentArray | undefined;if (args) {argNodes = isCallArgumentMap(args)? mapValues(args, (arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg))): args.map((arg) => (isGraphNode(arg) ? arg : withScopeFrom(node, arg)));}const traverseTarget = traverse(targetNode.definition, callOperation(argNodes));return resolve([{ target: withScopeFrom(targetNode, traverseTarget) }], updateState);}),});},},},})
Const CallOperationType
Call
OperationType: OperationType<"call", CallProperties> = createOperationType<'call',CallProperties>('call', {cacheable: false,shape: {args: types.optional(types.oneOfType([types.arrayOf(types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition])),types.objectOf(types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition])),]),),},})
Const CatchErrorNodeType
Catch
ErrorNodeType: StaticNodeType<"catch-error", CatchErrorNodeProperties> = createNodeType<'catch-error', CatchErrorNodeProperties>('catch-error', {deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},})
Const CeilNodeType
Ceil
NodeType: StatelessNodeType<"ceil", CeilNodeProperties> = createNodeType<'ceil',CeilNodeProperties>('ceil', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: CeilNodeProperties): Array<NodeDependency> {return [{ target, until: untilNumberValueNode(CeilNodeType, 'target') }];},run(node: CeilNode, options: never, [target]: [ValueNode<number>]): NodeDefinition {return toValue(Math.ceil(target.definition.properties.value));},},},})
Const CharAtNodeType
Char
AtNodeType: StatelessNodeType<"char-at", CharAtNodeProperties> = createNodeType<'char-at',CharAtNodeProperties>('char-at', {shape: {index: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ index, subject }: CharAtNodeProperties): Array<NodeDependency> {return [{target: index,until: untilPositiveIntegerValueNode(CharAtNodeType, 'index'),},{target: subject,acceptNil: true,until: untilStringValueNode(CharAtNodeType, 'subject'),},];},run(node: CharAtNode,options: never,[index, subject]: [ValueNode<number>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const indexValue = index.definition.properties.value;const content = subject.definition.properties.value;if (indexValue >= content.length) return nil();return value(content.charAt(indexValue));},},},})
Const ChooseNodeType
Choose
NodeType: StatelessNodeType<"choose", ChooseNodeProperties> = createNodeType<'choose',ChooseNodeProperties>('choose', {shape: {options: types.arrayOf(graphTypes.nodeDefinition),fallback: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ options }: ChooseNodeProperties): Array<NodeDependency> {return options.map((option) => ({target: option.properties.pattern,until: untilConditionIsValueNode,}));},run(node: ChooseNode, operation: never, conditions: Array<ValueNode<any>>): NodeDefinition {const { fallback, options } = node.definition.properties;const matchIndex = conditions.findIndex((condition) =>Boolean(condition.definition.properties.value),);if (matchIndex === -1) {return fallback.properties.value;}return options[matchIndex].properties.value;},},},})
Const ClampNodeType
Clamp
NodeType: StatelessNodeType<"clamp", ClampNodeProperties> = createNodeType<'clamp',ClampNodeProperties>('clamp', {shape: {max: graphTypes.nodeDefinition,min: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ max, min, value }: ClampNodeProperties): Array<NodeDependency> {return [{ target: max, until: untilNumberValueNode(ClampNodeType, 'max') },{ target: min, until: untilNumberValueNode(ClampNodeType, 'min') },{ target: value, until: untilNumberValueNode(ClampNodeType, 'value') },];},run(node: ClampNode,options: never,[max, min, value]: [ValueNode<number>, ValueNode<number>, ValueNode<number>],): NodeDefinition {const maxNumber = max.definition.properties.value;const minNumber = min.definition.properties.value;const valueNumber = value.definition.properties.value;return toValue(Math.min(Math.max(valueNumber, minNumber), maxNumber));},},},})
Const ClearNodeType
Clear
NodeType: StatelessNodeType<"clear", ClearNodeProperties> = createNodeType<'clear',ClearNodeProperties>('clear', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target }: ClearNodeProperties): [NodeDependency] {return [{target,until: untilSupportsClearOperation,},];},run(node: ClearNode,options: never,[target]: [GraphNode, ValueNode<number>],context: never,): GraphAction {return createGraphAction(target, clearOperation());},},},})
Const CollectionNodeTypes
Collection
NodeTypes: Array<NodeType> = [...KeysNodeTypes,...TransformsNodeTypes,AddItemAtNodeType,ApplyTransformsNodeType,ArrayNodeType,ArrayListNodeType,ArrayReducerNodeType,ContainsNodeType,HeadNodeType,ItemWithIdNodeType,IterateNodeType,NodeListNodeType,PopNodeType,PushNodeType,ReduceNodeType,RemoveItemNodeType,RemoveItemAtNodeType,RemoveItemsNodeType,ShiftNodeType,TransduceNodeType,UnshiftNodeType,]
Const CombineLatestNodeType
Combine
LatestNodeType: StatelessNodeType<"combineLatest", CombineLatestNodeProperties> = createNodeType<'combineLatest', CombineLatestNodeProperties>('combineLatest', {shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {cacheable: false,getDependencies({ operations }: CombineLatestNodeProperties): Array<NodeDependency> {return operations.map((operation) => ({ target: operation }));},run(node: CombineLatestNode, options: never, dependencies: Array<GraphNode>): NodeDefinition {return array(dependencies.map((node) => node.definition));},},},})
Const CombinedMiddlewareNodeType
Const CombinedReducerNodeType
Combined
ReducerNodeType: StatelessNodeType<"combinedReducer", CombinedReducerNodeProperties> = createOperationComposer<'combinedReducer',TransformOperation['type']['name'],TransformOperation>('combinedReducer', ['init', 'step', 'result'])
Const ContainsNodeType
Contains
NodeType: StatelessNodeType<"contains", ContainsNodeProperties> = createNodeType<'contains', ContainsNodeProperties>('contains', {shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,comparator: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: ContainsNodeProperties): Array<NodeDependency> {return [{target,until: {predicate: supportsContainsOperation,errorMessage(node: GraphNode) {return getInvalidTypeErrorMessage('Target node does not support contains operation',{ received: node.definition },);},},},];},run(node: ContainsNode, operation: never, [target]: [GraphNode]): GraphAction {const { item, comparator } = node.definition.properties;return createGraphAction(target, containsOperation(item, comparator));},},},})
Const ContainsOperationType
Contains
OperationType: OperationType<"contains", ContainsProperties> = createOperationType<'contains', ContainsProperties>('contains', {shape: {item: graphTypes.nodeDefinition,comparator: graphTypes.nodeDefinition,},})
Const ContextNodeType
Context
NodeType: StatelessNodeType<"context", ContextNodeProperties> = createNodeType<'context',ContextNodeProperties>('context', {shape: {name: types.oneOfType<string | symbol>([types.string, types.symbol]),},operations: {evaluate: {getContextDependencies({ name }: ContextNodeProperties): [ContextDependency] {return [{ name, required: true, until: shallow }];},run(node: ContextNode,options: never,dependencies: Array<never>,[contextNode]: [GraphNode],): GraphNode {return contextNode;},},},})
Const CountNodeType
Count
NodeType: StatelessNodeType<"count", CountNodeProperties> = createNodeType('count',{operations: {transformItems: {run(node: CountNode, operation: TransformItemsOperation): NodeDefinition {return nodeList([withScopeFrom(node, value(operation.properties.items.length))]);},},init: {run(node: CountNode): NodeDefinition {const initialState = 0;return value(initialState);},},step: {run(node: CountNode, operation: StepOperation<number>): NodeDefinition {return value(operation.properties.acc + 1);},},result: {run(node: CountNode, operation: ResultOperation<number>): NodeDefinition {const { acc, next } = operation.properties;const finalValue = array([value(acc)]);return next ? value(transduce(finalValue, [next])) : value(finalValue);},},},},)
Const CreateBehaviorNodeType
Create
BehaviorNodeType: StatelessNodeType<"createBehavior", CreateBehaviorNodeProperties> = createNodeType<'createBehavior', CreateBehaviorNodeProperties>('createBehavior', {serialize: false,deserialize: false,shape: {operations: types.objectOf(types.saveHash(types.func)),},operations: {[WILDCARD_OPERATION]: {run(node: CreateBehaviorNode, operation: GraphOperation): NodeDefinition {const operationHandler = node.definition.properties.operations[operation.type.name];if (!operationHandler) {return error(getInvalidTypeError(`This createBehavior node does not implement the '${operation.type.name}' operation.`,{expected: Object.keys(node.definition.properties.operations),received: operation.type.name,},),);}return operationHandler(getParams(node.context), operation.properties);},},},})
Const CreateCallerNodeType
Create
CallerNodeType: StaticNodeType<"createCaller", CreateCallerNodeProperties> = createNodeType<'createCaller', CreateCallerNodeProperties>('createCaller', {shape: {key: types.saveHash(types.any),disposeEmitter: types.optional(types.saveHash(types.func)),matcher: types.saveHash(types.func),},})
Const CreateSetterNodeType
Create
SetterNodeType: StaticNodeType<"createSetter", CreateSetterNodeProperties> = createNodeType<'createSetter', CreateSetterNodeProperties>('createSetter', {shape: {key: types.saveHash(types.any),disposeEmitter: types.optional(types.saveHash(types.func)),matcher: types.saveHash(types.func),},})
Const DEFAULT
DEFAULT: symbol = Symbol('DEFAULT')
Const DEFAULT_NODE_TYPES
DEFAULT_
NODE_TYPES: Array<NodeType> = [...ArithmeticNodeTypes,...BrowserNodeTypes,...CollectionNodeTypes,...GraphNodeTypes,...LogicNodeTypes,...RemoteNodeTypes,...StringNodeTypes,]
Const DebugNodeType
Debug
NodeType: StatelessNodeType<"debug", DebugNodeProperties> = createNodeType<'debug',DebugNodeProperties>('debug', {serialize: false,deserialize: false,shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: DebugNodeProperties): [NodeDependency] {return [{target,allowPending: true,allowErrors: true,acceptNil: true,},];},run(node: DebugNode, options: never, [targetValue]: [GraphNode]): NodeDefinition {const { target } = node.definition.properties;const input = target;const resolved = targetValue.definition;window.console.log({ input, resolved });debugger;return target;},},},})
Const DeferNodeType
Defer
NodeType: StaticNodeType<"defer", DeferNodeProperties> = createNodeType<'defer',DeferNodeProperties>('defer', {deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},})
Const DispatchNodeType
Dispatch
NodeType: StatelessNodeType<"dispatch", DispatchNodeProperties> = createNodeType<'dispatch', DispatchNodeProperties>('dispatch', {shape: {event: graphTypes.event,},operations: {evaluate: {cacheable: false,run(node: DispatchNode): NodeDefinition {const { event } = node.definition.properties;node.scope.events.emit(event);return ok();},},},})
Const DivideNodeType
Divide
NodeType: StatelessNodeType<"divide", DivideNodeProperties> = createNodeType<'divide',DivideNodeProperties>('divide', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: DivideNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(DivideNodeType, 'operand'),}));},run(node: DivideNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {assertEnoughOperands(operands);const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total / value));},},},})
Const DoneNodeType
Done
NodeType: StaticNodeType<"done", DoneNodeProperties> = createNodeType<'done',DoneNodeProperties>('done', {shape: {value: types.optional(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),},})
Const EMPTY_CONTEXT_DEPENDENCIES
EMPTY_CONTEXT_DEPENDENCIES: Array<never> = []
Const EMPTY_HASH_SET
EMPTY_HASH_SET: Set<string> = createHashSet()
Const EVENT_RESET_VARIABLE
EVENT_RESET_VARIABLE: "$$event:reset-variable" = "$$event:reset-variable"
Const EndsWithNodeType
Ends
WithNodeType: StatelessNodeType<"ends-with", EndsWithNodeProperties> = createNodeType<'ends-with', EndsWithNodeProperties>('ends-with', {shape: {pattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ pattern, subject }: EndsWithNodeProperties): Array<NodeDependency> {return [{target: pattern,until: untilStringValueNode(EndsWithNodeType, 'pattern'),},{target: subject,acceptNil: true,until: untilStringValueNode(EndsWithNodeType, 'subject'),},];},run(node: EndsWithNode,options: never,[pattern, subject]: [ValueNode<string>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return value(false);const patternValue = pattern.definition.properties.value;const subjectValue = subject.definition.properties.value;return value((subjectValue || '').endsWith(patternValue));},},},})
Const EntriesNodeType
Entries
NodeType: StaticNodeType<"entries", EntriesNodeProperties> = createNodeType<'entries',EntriesNodeProperties>('entries', {shape: {children: types.optional(graphTypes.nodeDefinition),},})
Const EqNodeType
Eq
NodeType: StatelessNodeType<"eq", EqNodeProperties> = createNodeType<'eq',EqNodeProperties>('eq', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: EqNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Eq node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: EqNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue === rightValue);},},},})
Const ErrorNodeType
Error
NodeType: StaticNodeType<"error", ErrorNodeProperties, SerializedErrorNodeProperties> = createNodeType<'error', ErrorNodeProperties, SerializedErrorNodeProperties>('error', {shape: {error: types.shape({message: types.string,stack: types.ignore,}),code: types.optional(types.string),data: types.optional(types.saveHash(types.any)),path: types.optional(types.saveHash(types.arrayOf(types.any))),remotePath: types.optional(types.saveHash(types.arrayOf(types.any))),},serialize(properties: ErrorNodeProperties): SerializedErrorNodeProperties {const { error, code, data, path, remotePath } = properties;return {error: error instanceof Error ? { message: error.message, stack: error.stack } : error,code,data,path,remotePath,};},deserialize(data: SerializedErrorNodeProperties): ErrorNodeProperties {const safeData = data || {};const error = safeData.error || new Error('Unknown error');return {error,code: safeData.code,data: safeData.data,path: safeData.path,remotePath: safeData.remotePath,};},})
Const EvaluateOperationType
Evaluate
OperationType: OperationType<"evaluate"> = createOperationType<'evaluate'>('evaluate',)
Const ExtendNodeType
Extend
NodeType: StatelessNodeType<"extend", ExtendNodeProperties> = createNodeType<'extend',ExtendNodeProperties>('extend', {shape: {nodes: types.arrayOf(graphTypes.nodeDefinition),},operations: {getChild: {run(node: ExtendNode, operation: GetChildOperation): NodeDefinition {return resolveChildNode(node, node.definition.properties.nodes, operation.properties.key);},},},})
Const ExternalStatefulNodeType
External
StatefulNodeType: StatefulNodeType<"stateful", ExternalStatefulNodeProperties<any>, ExternalStatefulNodeState> = createNodeType<'stateful', ExternalStatefulNodeProperties<any>, ExternalStatefulNodeState>('stateful',{state: {currentValue: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},shape: {valueStream: types.saveHash(types.any),},getInitialState(): ExternalStatefulNodeState {return {currentValue: pending(),};},serialize: false,deserialize: false,operations: {evaluate: {run(node: ExternalStatefulNode<any>,options: never,dependencies: Array<never>,context: Array<never>,state: ExternalStatefulNodeState,): NodeDefinition | GraphNode {return state.currentValue;},onSubscribe(this: NodeExecutionContext<ExternalStatefulNodeState, ExternalStatefulNodeData>,node: ExternalStatefulNode<any>,): void {const subscription = node.definition.properties.valueStream.subscribe((v) => {this.setState((s) => ({...s,currentValue: isGraphNode(v) ? v : toValue(v),}));});this.setData({subscription,});},onUnsubscribe(this: NodeExecutionContext<ExternalStatefulNodeState, ExternalStatefulNodeData>,): void {const subscription = this.getData().subscription;subscription && subscription.unsubscribe();},},},},)
Const FACTORY
FACTORY: unique symbol = Symbol('HASH_FACTORY')
Const FLUSH
FLUSH: "$$event:flush" = "$$event:flush"
Const FactoryNodeType
Factory
NodeType: StatefulNodeType<"factory", FactoryNodeProperties, FactoryNodeState, FactoryNodeData> = createNodeType<'factory', FactoryNodeProperties, FactoryNodeState, FactoryNodeData>('factory', {state: {instance: graphTypes.nodeDefinition,},serialize: false,deserialize: false,shape: {factory: types.saveHash(types.func),},getInitialState(): FactoryNodeState {return {instance: pending(),};},operations: {evaluate: {run(node: FactoryNode,options: never,dependencies: Array<never>,contextDependencies: Array<never>,state: FactoryNodeState,): NodeDefinition {const { instance } = state;return instance;},onSubscribe(this: NodeExecutionContext<FactoryNodeState, FactoryNodeData>,node: FactoryNode,): void {const { factory } = node.definition.properties;this.setState({instance: factory(),});},onInvalidate(this: NodeExecutionContext<FactoryNodeState, FactoryNodeData>,node: FactoryNode,): void {const { factory } = node.definition.properties;this.setState({instance: factory(),});},onUnsubscribe(this: NodeExecutionContext<FactoryNodeState, FactoryNodeData>,node: FactoryNode,): void {this.setState({instance: pending(),});},},},})
Const FetchItemsNodeType
Fetch
ItemsNodeType: StaticNodeType<"fetch-items", FetchItemsNodeProperties> = createNodeType<'fetch-items', FetchItemsNodeProperties>('fetch-items', {shape: {target: graphTypes.nodeDefinition,},operations: {getItems: {getDependencies({ target }: FetchItemsNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsGetItemOperation,},];},run(node: FetchItemsNode, operation: GetItemsOperation, [target]: [GraphNode]) {if (NilNodeType.is(target)) return target;const { transforms } = operation.properties;return resolve([{ target: traverse(target, getItemsOperation()), until: untilPlaceholderOrItems }],([items]: [GraphNode]) => {if (NilNodeType.is(items)) return items;if (!PlaceholderNodeType.is(items)) {return createGraphAction(items, getItemsOperation(transforms));}return applyTransforms(withScopeFrom(items, nodeList([items])) as NodeListNode,transforms,);},);},},},})
Const FieldsNodeType
Fields
NodeType: StaticNodeType<"fields", FieldsNodeProperties, SerializedFieldsNodeProperties> = createNodeType<'fields', FieldsNodeProperties, SerializedFieldsNodeProperties>('fields', {shape: {fields: types.objectOf(graphTypes.nodeDefinition),},serialize<T>({ fields }: FieldsNodeProperties,serialize: (node: NodeDefinition) => T,): SerializedFieldsNodeProperties<T> {return {fields: mapValues(fields, (field) => serialize(field)),};},deserialize<T>({ fields }: SerializedFieldsNodeProperties<T>,deserialize: (node: T) => NodeDefinition,): FieldsNodeProperties {return {fields: mapValues(fields, (field) => deserialize(field)),};},})
Const FilterNodeType
Filter
NodeType: StatelessNodeType<"filter", FilterNodeProperties> = createNodeType('filter',{shape: {predicate: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ predicate }: FilterNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => ({target: apply([item], predicate),until: untilIsValueNode,}));},run(node: FilterNode,operation: TransformItemsOperation,filterResults: Array<ValueNode<any>>,): NodeDefinition {const { items } = operation.properties;const filterValues = filterResults.map((result) => result.definition.properties.value);return nodeList((zip<GraphNode | ValueNode<any>>(items, filterValues) as Array<[GraphNode, ValueNode<any>]>).filter(([item, filterValue]) => Boolean(filterValue)).map(([item]) => item),);},},init: {run(node: FilterNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;if (!next) {return error('Filter reducer cannot be used as a base reducer');}return createGraphAction(next, init());},},step: {getDependencies({ predicate }: FilterNodeProperties,operation: StepOperation<any>,): [NodeDependency] {return [{target: apply([operation.properties.item], predicate),until: untilIsValueNode,},];},run(node: FilterNode,operation: StepOperation<any>,[result]: [ValueNode<any>],): NodeDefinition | GraphAction {const { acc, item, next } = operation.properties;if (!next) {return error('Filter reducer cannot be used as a base reducer');}const { value: resultValue } = result.definition.properties;return resultValue ? createGraphAction(next, step(acc, item)) : value(acc);},},result: {run(node: FilterNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Filter reducer cannot be used as a base reducer');}return createGraphAction(next, result(acc));},},},},)
Const FirstItemNodeType
First
ItemNodeType: StatelessNodeType<"firstItem", FirstItemNodeProperties> = createNodeType('firstItem', {operations: {transformItems: {run(node: FirstItemNode, operation: TransformItemsOperation): NodeDefinition {return nodeList(operation.properties.items.slice(0, 1));},},init: {run(node: FirstItemNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;return next ? createGraphAction(next, init()) : value(undefined);},},step: {run(node: FirstItemNode, operation: StepOperation<any>): NodeDefinition {const { acc, item, next } = operation.properties;return done(next ? traverse(next, step(acc, item)) : value(item));},},result: {run(node: FirstItemNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;return next ? createGraphAction(next, result(acc)) : value(nodeList(acc ? [acc] : []));},},},})
Const FirstNodeType
First
NodeType: StaticNodeType<"first"> = createNodeType<'first'>('first')
Const FloorNodeType
Floor
NodeType: StatelessNodeType<"floor", FloorNodeProperties> = createNodeType<'floor',FloorNodeProperties>('floor', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: FloorNodeProperties): Array<NodeDependency> {return [{ target, until: untilNumberValueNode(FloorNodeType, 'target') }];},run(node: FloorNode, options: never, [target]: [ValueNode<number>]): NodeDefinition {return toValue(Math.floor(target.definition.properties.value));},},},})
Const FlowNodeType
Flow
NodeType: StatelessNodeType<"flow", FlowNodeProperties> = createNodeType<'flow',FlowNodeProperties>('flow', {shape: {functions: types.arrayOf(graphTypes.nodeDefinition),},operations: {call: {run(node: FlowNode, operation: CallOperation) {return composeApplyNodes(node.definition.properties.functions, operation.properties.args);},},},})
Const FnNodeType
Fn
NodeType: StatelessNodeType<"fn", FnNodeProperties> = createNodeType<'fn',FnNodeProperties>('fn', {shape: {argIds: types.arrayOf(types.string),body: graphTypes.nodeDefinition,hasNamedArgs: types.bool,},operations: {call: {run(node: FnNode, operation: CallOperation): NodeDefinition | GraphNode {const { argIds, body, hasNamedArgs } = node.definition.properties;const { args } = operation.properties;if (hasNamedArgs) {// Handle calling function with named argumentsif (args && isCallArgumentArray(args)) {return error('An fn() expected to have been called with named arguments, ' +'but was called with an array of arguments.',);}const receivedArgsNames = args ? Object.keys(args) : [];const isMissingArguments = argIds.some((name) => !receivedArgsNames.includes(name));if (isMissingArguments) {return error(getInvalidTypeError('An fn() was called with unexpected number of arguments.', {expected: argIds,received: receivedArgsNames,}),);}const sanitizedArgs = fromPairs(toPairs(args).map(([name, value]) => [`$$named-arg:${name}`,isGraphNode(value) ? value : withScopeFrom(node, value),]),);const childContext = createContext(node.context, sanitizedArgs);return createGraphNode(node.scope, childContext, body);}// Handle calling function with an array of argumentsif (args && isCallArgumentMap(args)) {return error('An fn() expected to have been called with an array of arguments, ' +'but was called with named arguments.',);}if ((!args && argIds.length > 0) || (args && args.length < argIds.length)) {return error(getInvalidTypeError('Too few arguments applied to fn.', {expected: argIds.length,received: args ? args.length : 0,}),);}const trimmedArgs = (args ? args.slice(0, argIds.length) : []).map((arg) =>isGraphNode(arg) ? arg : withScopeFrom(node, arg),);const context = fromPairs(zip<string | GraphNode>(argIds, trimmedArgs) as Array<[string, GraphNode]>);const childContext = createContext(node.context, context);return createGraphNode(node.scope, childContext, body);},},},})
Const FormatNodeType
Format
NodeType: StatelessNodeType<"format", FormatNodeProperties> = createNodeType<'format',FormatNodeProperties>('format', {shape: {format: types.string,data: types.arrayOf(types.arrayOf(types.oneOfType<string | NodeDefinition>([types.string, graphTypes.nodeDefinition]),),),},operations: {evaluate: {getDependencies({ data }: FormatNodeProperties): Array<NodeDependency> {return data.map(([key, dependency]) => ({target: dependency,until: untilStringValueNode(FormatNodeType, `data.${key}`),}));},run(node: FormatNode,options: never,dependencies: Array<ValueNode<string>>,): NodeDefinition {const data = buildFormatInput(node.definition.properties.data, dependencies);return value(es6TemplateStrings(node.definition.properties.format, data));},},},})
Const FromBase64NodeType
From
Base64NodeType: StatelessNodeType<"from-base64", FromBase64NodeProperties> = createNodeType<'from-base64', FromBase64NodeProperties>('from-base64', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: FromBase64NodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(FromBase64NodeType, 'subject'),},];},run(node: FromBase64Node, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(atob(subject.definition.properties.value));},},},})
Const FromPromiseNodeType
From
PromiseNodeType: StatefulNodeType<"fromPromise", FromPromiseNodeProperties, FromPromiseNodeState> = createNodeType<'fromPromise', FromPromiseNodeProperties, FromPromiseNodeState>('fromPromise', {serialize: false,deserialize: false,state: {currentValue: types.optional(graphTypes.nodeDefinition),pendingUpdate: types.optional(types.saveHash(types.any)),updateError: types.optional(graphTypes.nodeDefinition),},shape: {get: types.optional(types.saveHash(types.func)),set: types.optional(types.saveHash(types.func)),},getInitialState(): FromPromiseNodeState {return {currentValue: undefined,pendingUpdate: undefined,updateError: undefined,};},operations: {evaluate: {run(node: FromPromiseNode,options: never,dependencies: Array<never>,context: Array<never>,state: FromPromiseNodeState,): NodeDefinition {const { get } = node.definition.properties;if (!get) {return error('Specified fromPromise node is write-only');}const { currentValue } = state;return currentValue || pending();},onInvalidate(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,): void {this.setState((state) => ({...state,currentValue: undefined,pendingUpdate: undefined,updateError: undefined,}));fetchValue(this, node);},onSubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,): void {this.setData((data) => ({...data,isSubscribed: true,}));fetchValue(this, node);},onUnsubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>): void {this.setData((data) => ({...data,isSubscribed: false,}));},},set: {run(node: FromPromiseNode,options: never,dependencies: Array<never>,context: Array<never>,state: FromPromiseNodeState,): NodeDefinition {const { set } = node.definition.properties;if (!set) {return error('Specified fromPromise node is read-only');}return state.pendingUpdate ? pending() : state.updateError || ok();},onSubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,operation: SetOperation,): void {const { set } = node.definition.properties;if (!set) return;const { value: newValue } = operation.properties;const { currentValue: previousValue } = this.getState();if (!previousValue) {this.retain();}this.setData((data) => ({...data,pendingGet: undefined,}));const pendingUpdate = Promise.resolve(set(getParams(node.context), valueOf(newValue))).catch((e) => error(e)).then((result) => {if (this.getState().pendingUpdate !== pendingUpdate) return result;this.setState((state) => ({...state,currentValue: isOkNodeDefinition(result) ? newValue : state.currentValue,pendingUpdate: undefined,updateError: isErrorNodeDefinition(result) ? result : undefined,}));return result;});this.setState((state) => ({...state,pendingUpdate,updateError: undefined,}));},},reset: {run(): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<FromPromiseNodeState, FromPromiseNodeData>,node: FromPromiseNode,) {const { currentValue: previousValue } = this.getState();if (previousValue) {this.release();}this.setState((state) => ({...state,currentValue: undefined,pendingUpdate: undefined,}));const { isSubscribed } = this.getData();if (isSubscribed) {fetchValue(this, node);}},},},})
Const FromStreamMiddlewareNodeType
From
StreamMiddlewareNodeType: StatelessNodeType<"from-stream-middleware", FromStreamMiddlewareNodeProperties> = createNodeType<'from-stream-middleware', FromStreamMiddlewareNodeProperties>('from-stream-middleware',{shape: {streamFactory: types.saveHash(types.func),},operations: {request: {run(node: FromStreamMiddlewareNode, operation: RequestOperation): NodeDefinition {const responseStream = node.definition.properties.streamFactory(operation.properties.query,);return fromStream(responseStream);},},},},)
Const FromStreamNodeType
From
StreamNodeType: StatefulNodeType<"fromStream", FromStreamNodeProperties, FromStreamNodeState> = createNodeType<'fromStream', FromStreamNodeProperties, FromStreamNodeState>('fromStream', {serialize: false,deserialize: false,state: {currentValue: types.optional(graphTypes.nodeDefinition),},shape: {factory: types.saveHash(types.oneOfType<Function | { subscribe: Function }>([types.func,types.instance({ subscribe: types.func }),types.shape({ subscribe: types.func }),]),),},getInitialState(): FromStreamNodeState {return {currentValue: undefined,};},operations: {evaluate: {run(node: FromStreamNode,options: never,dependencies: Array<never>,context: Array<never>,state: FromStreamNodeState,): NodeDefinition {const { currentValue } = state;return currentValue || pending();},onSubscribe(this: NodeExecutionContext<FromStreamNodeState, FromStreamNodeData>,node: FromStreamNode,): void {const { factory } = node.definition.properties;const { subscription: existingSubscription } = this.getData();let isSync = true;let syncValue: NodeDefinition | undefined;const stream = typeof factory === 'function' ? factory(getParams(node.context)) : factory;const subscription = stream.subscribe((rawValue) => {const valueNode = isNodeDefinition(rawValue) ? rawValue : value(rawValue);if (isSync) {syncValue = valueNode;} else {this.setState({currentValue: valueNode,});}});isSync = false;if (existingSubscription) {existingSubscription.unsubscribe();}this.setData({subscription,});if (syncValue) {this.setState({currentValue: syncValue,});}},onUnsubscribe(this: NodeExecutionContext<FromStreamNodeState, FromStreamNodeData>): void {const { subscription } = this.getData();subscription && subscription.unsubscribe();},},},})
Const FuzzyTraverseNodeType
Fuzzy
TraverseNodeType: StatelessNodeType<"fuzzyTraverse", FuzzyTraverseNodeProperties> = createNodeType<'fuzzyTraverse', FuzzyTraverseNodeProperties>('fuzzyTraverse', {serialize: false,deserialize: false,shape: {operation: graphTypes.graphOperation,target: types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition]),},operations: {evaluate: {getDependencies({ operation, target }: FuzzyTraverseNodeProperties): Array<NodeDependency> {return [{target,until: {predicate(node: GraphNode) {return supportsOperationType(operation.type.name, node.definition);},errorMessage(node: GraphNode) {return getInvalidTypeErrorMessage(`Node does not support ${operation.type.name} operation`,{expected: `Node supporting ${operation.type.name} operation`,received: node.definition,},);},},},];},run(node: FuzzyTraverseNode, operation: never, [target]: Array<never>): GraphAction {return createGraphAction(target, node.definition.properties.operation);},},},})
Const GRAPH_ACTION
GRAPH_ACTION: unique symbol = Symbol.for('muster::GRAPH_ACTION')
Const GRAPH_NODE
GRAPH_NODE: unique symbol = Symbol.for('muster::GRAPH_NODE')
Const GRAPH_OPERATION
GRAPH_OPERATION: unique symbol = Symbol.for('muster::GRAPH_OPERATION')
Const GetChildOperationType
Get
ChildOperationType: OperationType<"getChild", GetChildProperties> = createOperationType<'getChild', GetChildProperties>('getChild', {shape: {key: types.optional(types.saveHash(types.any)),},})
Const GetItemsOperationType
Get
ItemsOperationType: OperationType<"getItems", GetItemsProperties> = createOperationType<'getItems', GetItemsProperties>('getItems', {shape: {transforms: types.arrayOf(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),},})
Const GetLengthNodeType
Get
LengthNodeType: StatelessNodeType<"get-length", GetLengthNodeProperties> = createNodeType<'get-length', GetLengthNodeProperties>('get-length', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: GetLengthNodeProperties) {return [{target,until: {predicate: supportsLengthOperation,errorMessage(node: GraphNode) {return getInvalidTypeErrorMessage('Target node does not support length operation', {received: node.definition,});},},},];},run(node: GetLengthNode, operation: never, [target]: [GraphNode]): GraphAction {return createGraphAction(target, lengthOperation());},},},})
Const GetNodeType
Get
NodeType: StatelessNodeType<"get", GetNodeProperties> = createNodeType<'get',GetNodeProperties>('get', {shape: {subject: graphTypes.nodeDefinition,key: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject, key }: GetNodeProperties): Array<NodeDependency> {return [{target: subject,until: untilNodeSupportedByGet,},{target: key,until: untilIsValueNodeOrKeyNode,},];},run(node: GetNode,operation: never,[subjectNode, keyNode]: [GraphNode, ValueNode<any> | ListKeyNode],): NodeDefinition | GraphNode | GraphAction {if (isListKeyNode(keyNode)) {if (FirstNodeType.is(keyNode)) {return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [firstItem()])),);}if (LastNodeType.is(keyNode)) {return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [lastItem()])),);}if (NthNodeType.is(keyNode)) {const { index } = keyNode.definition.properties;return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [nthItem(index)])),);}if (LengthNodeType.is(keyNode)) {if (supportsLengthOperation(subjectNode)) {return withScopeFrom(subjectNode, length(subjectNode.definition));}return withScopeFrom(subjectNode,head(applyTransforms(subjectNode.definition, [count()])),);}}if (!supportsGetChildOperation(subjectNode)) {return withScopeFrom(subjectNode,error(untilNodeSupportedByGet.errorMessage(subjectNode)),);}return createGraphAction(subjectNode,getChildOperation(keyNode.definition.properties.value),);},},},})
Const GraphNodeNodeType
Graph
NodeNodeType: StatelessNodeType<"graphNode", GraphNodeNodeProperties> = createNodeType<'graphNode', GraphNodeNodeProperties>('graphNode', {deserialize: false,serialize: false,shape: {value: graphTypes.graphNode,},operations: {evaluate: {run(node: GraphNodeNode): GraphNode {return node.definition.properties.value;},},},})
Const GraphNodeTypes
Graph
NodeTypes: Array<NodeType> = [ActionNodeType,ApplyNodeType,CallNodeType,CatchErrorNodeType,CombineLatestNodeType,ContextNodeType,CreateCallerNodeType,CreateSetterNodeType,CreateBehaviorNodeType,DebugNodeType,DeferNodeType,DispatchNodeType,DoneNodeType,EntriesNodeType,ErrorNodeType,ExtendNodeType,FactoryNodeType,FieldsNodeType,ExternalStatefulNodeType,FlowNodeType,FnNodeType,FromPromiseNodeType,FromStreamNodeType,GetNodeType,GraphNodeNodeType,IfErrorNodeType,IfPendingNodeType,InvalidateNodeType,InvalidateOnNodeType,IsNilNodeType,IsPendingNodeType,IsUpdatingNodeType,IteratorResultNodeType,KeyNodeType,LegacyQueryNodeType,LogNodeType,NilNodeType,OkNodeType,OnNodeType,OnceNodeType,OptimisticNodeType,ParallelNodeType,ParamNodeType,ParentNodeType,InjectDependenciesNodeType,PartialNodeType,PendingNodeType,PlaceholderNodeType,PropertyNodeType,QueryNodeType,QuerySetNodeType,QuerySetCallOperationNodeType,QuerySetGetChildOperationNodeType,QuerySetGetItemsOperationNodeType,QuerySetOperationNodeType,QuerySetResultNodeType,QuerySetSetOperationNodeType,ResetNodeType,ResolveNodeType,RootNodeType,ScopeNodeType,SeriesNodeType,SetNodeType,SetResultNodeType,TakeLastNodeType,TraverseNodeType,TreeNodeType,UpdateNodeType,ValueNodeType,VariableNodeType,WithContextNodeType,WithScopeNodeType,WithTransformsNodeType,]
Const GroupByNodeType
Group
ByNodeType: StatelessNodeType<"group-by", GroupByNodeProperties> = createNodeType('group-by',{shape: {predicate: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ predicate }: GroupByNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => ({target: apply([item], predicate),until: untilIsValueNode,}));},run(node: GroupByNode,operation: TransformItemsOperation,groupByResults: Array<ValueNode<any>>,): NodeDefinition {const { items } = operation.properties;const groupedItems: Map<any, Array<GraphNode>> = new Map();items.forEach((item, index) => {const key = groupByResults[index].definition.properties.value;const items = groupedItems.get(key);if (items) items.push(item);else groupedItems.set(key, [item]);});return nodeList([...groupedItems.entries()].map(([key, items]) => withScopeFrom(node, nodeList(items))),);},},init: {run(node: GroupByNode): NodeDefinition {const initialState = [] as Array<GraphNode>;return value(initialState);},},step: {run(node: GroupByNode, operation: StepOperation<Array<GraphNode>>): NodeDefinition {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {getDependencies({ predicate }: GroupByNodeProperties): Array<NodeDependency> {return [{target: predicate,until: untilSupportsCallOperation,},];},run(node: GroupByNode,operation: ResultOperation<Array<GraphNode>>,[predicate]: [GraphNode],): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('group-by reducer cannot be used as a base reducer');}const sortedItems = resolve(acc.map((item) => ({target: apply([item], predicate.definition),until: untilIsValueNode,})),(groupByResults: Array<ValueNode<any>>) => {const groupedItems: Map<any, Array<GraphNode>> = new Map();acc.forEach((item, index) => {const key = groupByResults[index].definition.properties.value;const items = groupedItems.get(key);if (items) items.push(item);else groupedItems.set(key, [item]);});return nodeList([...groupedItems.entries()].map(([key, items]) =>withScopeFrom(node, nodeList(items)),),);},);return value(transduce(sortedItems, [next]));},},},},)
Const GtNodeType
Gt
NodeType: StatelessNodeType<"gt", GtNodeProperties> = createNodeType<'gt',GtNodeProperties>('gt', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: GtNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Gt node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: GtNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue > rightValue);},},},})
Const GteNodeType
Gte
NodeType: StatelessNodeType<"gte", GteNodeProperties> = createNodeType<'gte',GteNodeProperties>('gte', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: GteNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Gte node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: GteNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue >= rightValue);},},},})
Const HeadNodeType
Head
NodeType: StatelessNodeType<"head", HeadNodeProperties> = createNodeType<'head',HeadNodeProperties>('head', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: HeadNodeProperties): Array<NodeDependency> {return [{target,until: untilValidTargetNode,},];},run(node: HeadNode,options: never,[targetNode]: [NodeListNode | IterableGraphNode | PlaceholderNode | ItemPlaceholderNode],): GraphNode | NodeDefinition {if (NilNodeType.is(targetNode) ||ItemPlaceholderNodeType.is(targetNode) ||PlaceholderNodeType.is(targetNode)) {return targetNode;}if (NodeListNodeType.is(targetNode)) {const { items } = targetNode.definition.properties;return items.length > 0 ? items[0] : nil();}if (supportsIterateOperation(node)) {return getNextIteratorResult(targetNode, resolveIteratorResult);}// the item must support get items operation thenreturn withScopeFrom(targetNode,resolve([{target: traverse(targetNode, getItemsOperation()),until: untilValidGetItemsResult,},],([itemsNode]: [NodeListNode]) => {if (NilNodeType.is(itemsNode) ||ItemPlaceholderNodeType.is(itemsNode) ||PlaceholderNodeType.is(itemsNode)) {return itemsNode;}const { items } = itemsNode.definition.properties;return items.length > 0 ? items[0] : nil();},),);},},},})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"arrayReducer", ArrayReducerNodeProperties, ArrayReducerNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(ArrayReducerNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"count", CountNodeProperties, CountNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(CountNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"identity", IdentityNodeProperties, IdentityNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(IdentityNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"root", object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(RootNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"nil", object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(NilNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"lastItem", LastItemNodeProperties, LastItemNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(LastItemNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"firstItem", FirstItemNodeProperties, FirstItemNodeProperties, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(FirstItemNodeType, {})
Const INSTANCE
INSTANCE
: StaticNodeDefinition<string, object, object, StatelessNodeType<"parent", object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>> = createNodeDefinition(ParentNodeType, {})
Const ITEM_ID_CONTEXT
ITEM_ID_CONTEXT: "$$array:item-id" = "$$array:item-id"
Const ITEM_ID_KEY
ITEM_ID_KEY: "$$item-with-id:id" = "$$item-with-id:id"
Const IdentityNodeType
Identity
NodeType: StatelessNodeType<"identity", IdentityNodeProperties> = createNodeType<'identity', IdentityNodeProperties>('identity', {shape: {},operations: {call: {run(node: IdentityNode, operation: CallOperation): GraphNode | NodeDefinition {const { args } = operation.properties;if (!args) return nil();if (isCallArgumentArray(args)) return args[0];const argsNames = Object.keys(args);return args[argsNames[0]];},},},})
Const IdentityOperationType
Identity
OperationType: OperationType<"identity"> = createOperationType<'identity'>('identity',)
Const IfElseNodeType
If
ElseNodeType: StatelessNodeType<"ifElse", IfElseNodeProperties> = createNodeType<'ifElse',IfElseNodeProperties>('ifElse', {shape: {if: graphTypes.nodeDefinition,then: graphTypes.nodeDefinition,else: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ if: ifNode }: IfElseNodeProperties): Array<NodeDependency> {return [{target: ifNode,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('IfElse node condition must resolve to value() nodes',{expected: ValueNodeType,received: node.definition,},);},},},];},run(node: IfElseNode, options: never, [condition]: [ValueNode<any>]): NodeDefinition {const { then: thenNode, else: elseNode } = node.definition.properties;const conditionValue = condition.definition.properties.value;return conditionValue ? thenNode : elseNode;},},},})
Const IfErrorNodeType
If
ErrorNodeType: StatefulNodeType<"ifError", IfErrorNodeProperties, IfErrorNodeState, IfErrorNodeData> = createNodeType<'ifError', IfErrorNodeProperties, IfErrorNodeState, IfErrorNodeData>('ifError', {state: {previousValues: types.shape({evaluate: types.optional(graphTypes.graphNode),}),},shape: {target: graphTypes.nodeDefinition,fallback: types.saveHash(types.func),},getInitialState(): IfErrorNodeState {return {previousValues: {evaluate: undefined,},};},operations: {evaluate: {getDependencies({ target }: IfErrorNodeProperties): Array<NodeDependency> {return [{target,allowErrors: true,},];},run(node: IfErrorNode,options: never,[target]: [GraphNode],context: Array<never>,state: IfErrorNodeState,): NodeDefinition | GraphNode {const { fallback } = node.definition.properties;const { previousValues } = state;if (ErrorNodeType.is(target)) {const previousValue = previousValues.evaluate;return fallback(target.definition, previousValue && previousValue.definition);}return target;},onUpdate(this: NodeExecutionContext<IfErrorNodeState, IfErrorNodeData>,node: IfErrorNode,options: never,[target]: [GraphNode],): void {if (!ErrorNodeType.is(target)) {this.setState((prevState) => ({previousValues: {...prevState.previousValues,evaluate: target,},}));}},},call: {run(node: IfErrorNode, operation: CallOperation): NodeDefinition | GraphNode {const { fallback, target } = node.definition.properties;return resolve([{ target: traverse(target, operation), allowErrors: true }], ([result]) => {if (ErrorNodeType.is(result)) {return withScopeFrom(node, fallback(result.definition, undefined));}return result;});},},},})
Const IfPendingNodeType
If
PendingNodeType: StatelessNodeType<"ifPending", IfPendingNodeProperties> = createNodeType<'ifPending', IfPendingNodeProperties>('ifPending', {shape: {target: graphTypes.nodeDefinition,fallback: types.oneOfType([types.saveHash(types.func),graphTypes.nodeDefinition,types.saveHash(types.any),]),},operations: {evaluate: {run(node: IfPendingNode) {const { fallback, target } = node.definition.properties;const fallbackGenerator = parseFallbackGenerator(fallback);const queryBuilder = new QueryBuilder(uniqueId('if-pending_'));let resolveMirrorQuery: NodeDefinition = ok();let lastQuerySnapshot: QueriesSnapshot | undefined = undefined;let lastResolvedResult: QuerySetResultNodeDefinition | undefined = undefined;return takeLast([onGlobalEvent(FLUSH)(() => {if (!queryBuilder.isModified) return resolveMirrorQuery;queryBuilder.resetModifiedState();const queryBuilderSnapshot = getQueryBuilderSnapshot(queryBuilder);if (lastQuerySnapshot && isEqual(lastQuerySnapshot, queryBuilderSnapshot)) {return resolveMirrorQuery;}lastQuerySnapshot = queryBuilderSnapshot;const querySetWithCallback = buildQuerySetFromQueryBuilderSnapshot(queryBuilderSnapshot,queryBuilder,);const querySetChildren = querySetWithCallback.node.properties.children;const querySetWithTarget = querySet(target, querySetChildren);return (resolveMirrorQuery = resolve([{target: withScopeFrom(node, querySetWithTarget),until: untilIsArrayNodeOrPendingNode,acceptNil: true,allowPending: true,},],([result]: [ArrayNode | PendingNode]) => {if (!PendingNodeType.is(result)) {// Looks like the query is fully resolved - call the placeholder callbackslastResolvedResult = querySetResult(querySetChildren, result.definition);querySetWithCallback.callback(result.definition);return ok();}// Generate the fallback response and then resolve it to a simpler valuereturn resolve([{target: fallbackGenerator(lastResolvedResult),acceptNil: true,},],([fallback]: [GraphNode]) => {// Check if the fallback was resolved to a query set node// This should simplify things a bitif (lastResolvedResult &&fallback.definition.id === lastResolvedResult.properties.result.id) {querySetWithCallback.callback((fallback as QuerySetResultNode).definition.properties.result,);return ok();}// Otherwise - run the querySet against the fallback to generate a correct resultreturn resolve([{target: withScopeFrom(fallback,querySet(fallback.definition, querySetChildren),),acceptNil: true,allowErrors: true,allowPending: true,},],([fallbackResult]: [GraphNode]) => {querySetWithCallback.callback(fallbackResult.definition);return ok();},);},);},));}),placeholder(queryBuilder, []),]);},},},})
Const IncludesNodeType
Includes
NodeType: StatelessNodeType<"includes", IncludesNodeProperties> = createNodeType<'includes', IncludesNodeProperties>('includes', {shape: {pattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ pattern, subject }: IncludesNodeProperties): Array<NodeDependency> {return [{target: pattern,until: untilStringValueNode(IncludesNodeType, 'pattern'),},{target: subject,acceptNil: true,until: untilStringValueNode(IncludesNodeType, 'subject'),},];},run(node: IncludesNode,options: never,[pattern, subject]: [ValueNode<string>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return value(false);const patternValue = pattern.definition.properties.value;const subjectValue = subject.definition.properties.value;return value((subjectValue || '').includes(patternValue));},},},})
Const InitOperationType
Init
OperationType: OperationType<"init", InitProperties> = createOperationType<'init',InitProperties>('init', {shape: {next: types.optional(graphTypes.graphNode),},})
Const InjectDependenciesNodeType
Inject
DependenciesNodeType: StatelessNodeType<"inject-dependencies", InjectDependenciesNodeProperties<NodeDefinition>> = createNodeType('inject-dependencies', {shape: {context: types.optional(types.objectOf(graphTypes.nodeDefinition)),dependencies: types.arrayOf(types.optional(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),),target: graphTypes.nodeDefinition,},serialize: false,deserialize: false,operations: {evaluate: {cacheable: true,getDependencies<T extends NodeDefinition>(properties: InjectDependenciesNodeProperties<T>,operation: EvaluateOperation,): Array<Dependency> {const { target } = properties;if (!supportsEvaluateOperation(target)) {return [];}const evaluateOperationHandler = target.type.operations.evaluate;return getDependencies(properties, evaluateOperationHandler, operation);},getContextDependencies<T extends NodeDefinition>(properties: InjectDependenciesNodeProperties<T>,operation: EvaluateOperation,): Array<ContextDependency> {const { target } = properties;if (!supportsEvaluateOperation(target)) {return [];}const evaluateOperationHandler = target.type.operations.evaluate;return getContextDependencies(properties, evaluateOperationHandler, operation);},run<T extends NodeDefinition>(node: InjectDependenciesNode<T>,operation: EvaluateOperation,dependencies: Array<GraphNode>,contextDependencies: Array<GraphNode>,): GraphNode | GraphAction {const { target, context } = node.definition.properties;if (!supportsEvaluateOperation(target)) {return withScopeFrom(node, target);}const nodeType = target.type;const {dependencies: resolvedDependencies,contextDependencies: resolvedContextDependencies,} = getResolvedDependencies(node.definition,nodeType.operations.evaluate,operation,dependencies,contextDependencies,);const targetContext = context? createContext(node.context, mapValues(context, (value) => withScopeFrom(node, value))): node.context;const targetNode = createGraphNode(node.scope, targetContext, target);if (isStatefulNodeType(nodeType)) {return nodeType.operations.evaluate.run(targetNode,evaluateOperation(),resolvedDependencies,resolvedContextDependencies,node.scope.store.getNodeState(targetNode as StatefulGraphNode),);}return nodeType.operations.evaluate.run(targetNode,evaluateOperation(),resolvedDependencies,resolvedContextDependencies,undefined,);},},},})
Const InvalidateNodeType
Invalidate
NodeType: StatefulNodeType<"invalidate", InvalidateNodeProperties> = createNodeType<'invalidate', InvalidateNodeProperties>('invalidate', {state: {},shape: {target: graphTypes.nodeDefinition,},getInitialState(): InvalidateNodeState {return {};},operations: {evaluate: {cacheable: false,run(): GraphNode | NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<InvalidateNodeState, InvalidateNodeData>,node: InvalidateNode,): void {if (!isDynamicNode(node)) {return;}const { target } = node.definition.properties;// Invalidate the target node via the store if it is already subscribedconst wasSubscribed = node.scope.store.invalidate(withScopeFrom(node, target));if (wasSubscribed) {return;}if (!supportsEvaluateOperation(target)) {return;}// The target node is not currently subscribed, so create a temporary subscription to the// target just in order to figure out the next result in the chain, and invalidate thatlet isSync = true;let isCompleted = false;const unsubscribe = node.scope.store.subscribe(withScopeFrom(node,resolve([createGraphAction(withScopeFrom(node, target), evaluateOperation())],([nextTarget]) => withScopeFrom(nextTarget, invalidate(nextTarget.definition)),),),resolveOperation(),() => {isCompleted = true;if (isSync) return;unsubscribe();},);isSync = false;if (isCompleted) {unsubscribe();}},},},})
Const InvalidateOnNodeType
Invalidate
OnNodeType: StatefulNodeType<"invalidate-on", InvalidateOnNodeProperties, InvalidateOnNodeState> = createNodeType<'invalidate-on', InvalidateOnNodeProperties, InvalidateOnNodeState>('invalidate-on',{state: {},shape: {target: graphTypes.nodeDefinition,predicate: types.saveHash(types.func),},getInitialState(): InvalidateOnNodeState {return {};},operations: {evaluate: {run(node: InvalidateOnNode): NodeDefinition {const { target } = node.definition.properties;return target;},onSubscribe(node: InvalidateOnNode) {const { predicate, target } = node.definition.properties;const { subscription: disposeSubscription } = this.getData();disposeSubscription && disposeSubscription();const subscription = node.scope.events.listen((event) => {if (!predicate(event)) return;const targetNode = withScopeFrom(node, target);node.scope.store.invalidate(targetNode);});this.setData({subscription,});},onUnsubscribe() {const { subscription: disposeSubscription } = this.getData();disposeSubscription && disposeSubscription();},},},},)
Const IsNilNodeType
Is
NilNodeType: StatelessNodeType<"is-nil", IsNilNodeProperties> = createNodeType<'is-nil',IsNilNodeProperties>('is-nil', {serialize: false,deserialize: false,shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: IsNilNodeProperties): [NodeDependency] {return [{target,acceptNil: true,},];},run(node: IsNilNode, options: never, [targetValue]: [GraphNode]): NodeDefinition {return value(NilNodeType.is(targetValue));},},},})
Const IsPendingNodeType
Is
PendingNodeType: StaticNodeType<"isPending", IsPendingNodeProperties> = createNodeType<'isPending', IsPendingNodeProperties>('isPending', {shape: {target: graphTypes.nodeDefinition,},})
Const IsPendingOperationType
Is
PendingOperationType: OperationType<"isPending"> = createOperationType<'isPending'>('isPending',)
Const IsUpdatingNodeType
Is
UpdatingNodeType: StatelessNodeType<"isUpdating", IsUpdatingNodeProperties> = createNodeType<'isUpdating', IsUpdatingNodeProperties>('isUpdating', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: IsUpdatingNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsIsUpdatingOperationOrStaticNode,},];},run(node: IsUpdatingNode,operation: never,[target]: [GraphNode],): NodeDefinition | GraphAction {if (!supportsIsUpdatingOperation(target)) {return value(true);}return createGraphAction(target, isUpdatingOperation());},},},})
Const IsUpdatingOperationType
Is
UpdatingOperationType: OperationType<"isUpdating"> = createOperationType<'isUpdating'>('isUpdating')
Const ItemPlaceholderNodeType
Item
PlaceholderNodeType: StatelessNodeType<"item-placeholder", ItemPlaceholderNodeProperties> = createNodeType<'item-placeholder', ItemPlaceholderNodeProperties>('item-placeholder', {shape: {results: types.arrayOf(types.shape({node: graphTypes.nodeDefinition,pathPart: types.shape({id: types.string,operation: graphTypes.graphOperation,}),}),),isEmpty: types.bool,path: types.arrayOf(types.shape({id: types.string,operation: graphTypes.graphOperation,}),),queryBuilder: types.saveHash(types.any),},operations: {[WILDCARD_OPERATION]: {getDependencies({ path, queryBuilder }: ItemPlaceholderNodeProperties,operation: GraphOperation,): Array<NodeDependency> {return [{target: traverse(placeholder(queryBuilder, path), operation),allowPending: true,until: untilValidPlaceholderResult,},];},run(node: ItemPlaceholderNode,operation: GraphOperation,[placeholder]: [PlaceholderNode],): NodeDefinition | GraphNode {const { results } = node.definition.properties;const matchingResult = results.find((result) => result.pathPart.id === operation.id);if (!matchingResult) return placeholder;return isSetOperation(operation) && isOkNodeDefinition(matchingResult.node)? operation.properties.value: matchingResult.node;},},},})
Const ItemWithIdNodeType
Item
WithIdNodeType: StatelessNodeType<"item-with-id", ItemWithIdNodeProperties> = createNodeType<'item-with-id', ItemWithIdNodeProperties>('item-with-id', {shape: {id: types.string,item: graphTypes.nodeDefinition,},operations: {evaluate: {run(node: ItemWithIdNode): GraphNode {const { id, item } = node.definition.properties;return createGraphNode(node.scope,createContext(node.context, {[ITEM_ID_KEY]: withScopeFrom(node, value(id)),}),item,);},},},})
Const IterateNodeType
Iterate
NodeType: StatelessNodeType<"iterate", IterateNodeProperties> = createNodeType<'iterate',IterateNodeProperties>('iterate', {shape: {target: graphTypes.nodeDefinition,transforms: types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),},operations: {evaluate: {getDependencies({ target, transforms }: IterateNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsIterateOperation,},...transforms.map((transformer) => ({target: transformer,until: untilSupportsStepOperation,})),];},run(node: IterateNode,options: never,[targetNode, ...transforms]: Array<GraphNode>,): NodeDefinition | GraphNode {return withScopeFrom(targetNode,transduce(targetNode.definition, [...transforms, arrayReducer()]),);},},},})
Const IterateOperationType
Iterate
OperationType: OperationType<"iterate"> = createOperationType<'iterate'>('iterate',)
Const IteratorResultNodeType
Iterator
ResultNodeType: StaticNodeType<"iteratorResult", IteratorResultNodeProperties> = createNodeType<'iteratorResult', IteratorResultNodeProperties>('iteratorResult', {shape: {value: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),next: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},})
Const JoinNodeType
Join
NodeType: StatelessNodeType<"join", JoinNodeProperties> = createNodeType<'join',JoinNodeProperties>('join', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),separator: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ operands, separator }: JoinNodeProperties): Array<NodeDependency> {return [{target: separator,until: untilValidSeparator,},...operands.map((operand) => ({target: operand,acceptNil: true,until: untilValidJoinOperand,})),];},run(node: JoinNode,options: never,[separator, ...operands]: [ValueNode<string>, ValueNode<string | Array<string>>],): NodeDefinition {return value(flatMap(operands.filter((operand) => !NilNodeType.is(operand)), (operand) => {const { value } = operand.definition.properties;return typeof value === 'string' ? [value] : value;}).join(separator.definition.properties.value),);},},},})
Const KeyNodeType
Key
NodeType: StaticNodeType<"key", KeyNodeProperties> = createNodeType<'key',KeyNodeProperties>('key', {shape: {key: graphTypes.nodeDefinition,children: types.optional(graphTypes.nodeDefinition),},})
Const KeysNodeTypes
Keys
NodeTypes: Array<NodeType> = [FirstNodeType,GetLengthNodeType,LastNodeType,LengthNodeType,NthNodeType,]
Const LOCATION_CHANGED
LOCATION_CHANGED: "$$event:location-changed" = "$$event:location-changed"
Const LOCATION_PART_CHANGED
LOCATION_PART_CHANGED: "$$event:location-part-changed" = "$$event:location-part-changed"
Const LastItemNodeType
Last
ItemNodeType: StatelessNodeType<"lastItem", LastItemNodeProperties> = createNodeType('lastItem', {operations: {transformItems: {run(node: LastItemNode, operation: TransformItemsOperation): NodeDefinition {return nodeList(operation.properties.items.slice(-1));},},init: {run(node: LastItemNode): NodeDefinition {return value(undefined);},},step: {run(node: LastItemNode, operation: StepOperation<any>): NodeDefinition {return value(operation.properties.item);},},result: {run(node: LastItemNode, operation: ResultOperation<any>): NodeDefinition {const { acc, next } = operation.properties;const finalValue = nodeList(acc ? [acc] : []);return next ? value(transduce(finalValue, [next])) : value(finalValue);},},},})
Const LegacyQueryNodeType
Legacy
QueryNodeType: StatelessNodeType<"legacyQuery", LegacyQueryNodeProperties> = createNodeType<'legacyQuery', LegacyQueryNodeProperties>('legacyQuery', {shape: {keys: graphTypes.nodeDefinition,root: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ keys }: LegacyQueryNodeProperties): [NodeDependency] {return [{target: keys,until: untilIsFieldsNodeOrCollectionFieldsNode,},];},run(node: LegacyQueryNode,operation: never,[keys]: [FieldsNode | EntriesNode | WithTransformsNode],): NodeDefinition | GraphNode {const { root } = node.definition.properties;if (FieldsNodeType.is(keys)) {if (supportsGetChildOperation(root)) {return resolveFields(withScopeFrom(node, root), keys);}return resolve([{target: root,until: untilSupportsGetChildOperation,},],([rootNode]) => resolveFields(rootNode, keys),);}if (isCollectionFieldsNode(keys)) {if (supportsGetItemsOperation(root)) {return resolveList(withScopeFrom(node, root), keys);}return resolve([{target: root,until: untilSupportsGetItemsOperation,},],([rootNode]) => resolveList(rootNode, keys),);}return error(getInvalidTypeError('Invalid query definition.', {expected: [FieldsNodeType, EntriesNodeType, WithTransformsNodeType],received: keys,}),);},},},})
Const LengthNodeType
Length
NodeType: StaticNodeType<"length"> = createNodeType<'length'>('length')
Const LengthOperationType
Length
OperationType: OperationType<"length", LengthProperties> = createOperationType<'length',LengthProperties>('length', {cacheable: false,shape: {},})
Const LocationDataNodeType
Location
DataNodeType: StatefulNodeType<"locationData", LocationDataNodeProperties, LocationDataNodeState> = createNodeType<'locationData', LocationDataNodeProperties, LocationDataNodeState>('locationData',{state: {currentValue: graphTypes.nodeDefinition,},shape: {history: types.shape({id: types.string,}),paramsEncoder: types.optional(types.shape({encode: types.saveHash(types.func),decode: types.saveHash(types.func),}),),update: types.optional(types.bool),},getInitialState(properties: LocationDataNodeProperties): LocationDataNodeState {return {currentValue: computeCurrentValue(properties.history.location, properties.paramsEncoder),};},operations: {evaluate: {run(node: LocationDataNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationDataNodeState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<LocationDataNodeState, LocationDataNodeData>,node: LocationDataNode,): void {if (this.getData().disposeEventListener) return;const { history, paramsEncoder } = node.definition.properties;this.setData({disposeEventListener: node.scope.events.listen((event) => {if (event.type !== LOCATION_CHANGED) return;this.setState({currentValue: computeCurrentValue(history.location, paramsEncoder),});}),disposeHistoryListener: history.listen((location) => {this.setState({currentValue: computeCurrentValue(location, paramsEncoder),});}),});},onUnsubscribe(this: NodeExecutionContext<LocationDataNodeState, LocationDataNodeData>,): void {const { disposeEventListener, disposeHistoryListener } = this.getData();disposeEventListener && disposeEventListener();disposeHistoryListener && disposeHistoryListener();},},set: {run(): NodeDefinition {return series([dispatch(LOCATION_PART_CHANGED), ok()]);},onSubscribe(this: NodeExecutionContext<LocationDataNodeState, LocationDataNodeData>,node: LocationDataNode,operation: SetOperation,): void {const { history } = node.definition.properties;const paramsValue = operation.properties.value.properties.value;getHistoryUpdater(history, node.definition.properties.update)({...history.location,search: paramsToSearch(paramsValue, node.definition.properties.paramsEncoder),});this.setState({currentValue: value(paramsValue),});},},},},)
Const LocationNodeType
Location
NodeType: StatefulNodeType<"location", LocationNodeProperties, LocationNodeState> = createNodeType<'location', LocationNodeProperties, LocationNodeState>('location', {state: {currentValue: graphTypes.nodeDefinition,history: types.shape({id: types.string,}),},shape: {hash: types.optional(types.string),paramsEncoder: types.optional(types.shape({encode: types.saveHash(types.func),decode: types.saveHash(types.func),}),),update: types.optional(types.bool),},getInitialState(properties: LocationNodeProperties): LocationNodeState {const history = (properties.hash? createHashHistory({ hashType: properties.hash }): createBrowserHistory({ forceRefresh: false })) as HistoryWithId;history.id = uniqueId('history_');return {currentValue: computeCurrentValue(history.location, properties.paramsEncoder),history,};},operations: {evaluate: {run(node: LocationNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationNodeState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<LocationNodeState, LocationNodeData>,node: LocationNode,): void {if (this.getData().unsubscribeHistory) return;const { history } = this.getState();const { paramsEncoder } = node.definition.properties;this.setData({unsubscribeEvent: node.scope.events.listen((event) => {if (event.type !== LOCATION_PART_CHANGED) return;this.setState((state) => ({...state,currentValue: computeCurrentValue(history.location, paramsEncoder),}));}),unsubscribeHistory: history.listen((location) => {this.setState((state) => ({...state,currentValue: computeCurrentValue(location, paramsEncoder),}));}),});},onUnsubscribe(this: NodeExecutionContext<LocationNodeState, LocationNodeData>): void {const { unsubscribeEvent, unsubscribeHistory } = this.getData();unsubscribeEvent && unsubscribeEvent();unsubscribeHistory && unsubscribeHistory();},},getChild: {run(node: LocationNode,operation: GetChildOperation,dependencies: Array<never>,context: Array<never>,state: LocationNodeState,): NodeDefinition | GraphNode {const { key } = operation.properties;const { history } = state;const childContext = createChildPathContext(node, key);if (key === 'path') {return createGraphNode(node.scope, childContext, locationPath(history));}if (key === 'params') {const { paramsEncoder, update } = node.definition.properties;return createGraphNode(node.scope,childContext,locationData(history, paramsEncoder, update),);}return nil();},},set: {run(node: LocationNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationNodeState,): NodeDefinition {return series([dispatch(LOCATION_CHANGED), ok()]);},onSubscribe(this: NodeExecutionContext<LocationNodeState, LocationNodeData>,node: LocationNode,operation: SetOperation,): void {const { history } = this.getState();const value = operation.properties.value.properties.value;const { paramsEncoder } = node.definition.properties;getHistoryUpdater(history, node.definition.properties.update)({pathname: value.path,search: paramsToSearch(value.params, paramsEncoder),});this.setState((state) => ({...state,currentValue: computeCurrentValue(history.location, paramsEncoder),}));},},},})
Const LocationPathNodeType
Location
PathNodeType: StatefulNodeType<"locationPath", LocationPathNodeProperties, LocationPathNodeState> = createNodeType<'locationPath', LocationPathNodeProperties, LocationPathNodeState>('locationPath',{state: {currentValue: graphTypes.nodeDefinition,},shape: {history: types.shape({id: types.string,}),update: types.optional(types.bool),},getInitialState(properties: LocationPathNodeProperties): LocationPathNodeState {return {currentValue: value(properties.history.location.pathname),};},operations: {evaluate: {run(node: LocationPathNode,options: never,dependencies: Array<never>,context: Array<never>,state: LocationPathNodeState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<LocationPathNodeState, LocationPathNodeData>,node: LocationPathNode,): void {if (this.getData().disposeEventListener) return;const { history } = node.definition.properties;this.setData({disposeEventListener: node.scope.events.listen((event) => {if (event.type !== LOCATION_CHANGED) return;this.setState({currentValue: value(history.location.pathname),});}),disposeHistoryListener: history.listen((location) => {this.setState((state) => ({...state,currentValue: value(location.pathname),}));}),});},onUnsubscribe(this: NodeExecutionContext<LocationPathNodeState, LocationPathNodeData>,): void {const { disposeEventListener, disposeHistoryListener } = this.getData();disposeEventListener && disposeEventListener();disposeHistoryListener && disposeHistoryListener();},},set: {run(): NodeDefinition {return series([dispatch(LOCATION_PART_CHANGED), ok()]);},onSubscribe(this: NodeExecutionContext<LocationPathNodeState, LocationPathNodeData>,node: LocationPathNode,operation: SetOperation,): void {const { history } = node.definition.properties;const pathValue = operation.properties.value.properties.value;getHistoryUpdater(history, node.definition.properties.update)({...history.location,pathname: pathValue,});this.setState({currentValue: value(pathValue),});},},},},)
Const LogMiddlewareNodeType
Log
MiddlewareNodeType: StatelessNodeType<"log-middleware", LogMiddlewareNodeProperties> = createNodeType<'log-middleware', LogMiddlewareNodeProperties>('log-middleware', {shape: {logRequests: types.bool,logResponses: types.bool,sink: types.saveHash(types.func),},operations: {request: {run(node: LogMiddlewareNode, operation: RequestOperation): NodeDefinition {const { logRequests, logResponses, sink } = node.definition.properties;const { metadata, next, query } = operation.properties;if (!next) {return error('LogMiddleware cannot be used as a base middleware.');}if (logRequests) {sink(`Request [${operation.id}]:`, getType(operation.properties.query));}return resolve([{target: withScopeFrom(next,traverse(next.definition, requestOperation(query, metadata)),),allowErrors: true,},],([response]) => {if (logResponses) {sink(`Response [${operation.id}]:`, getType(response.definition));}return response;},);},},},})
Const LogNodeType
Log
NodeType: StatelessNodeType<"log", LogNodeProperties> = createNodeType<'log',LogNodeProperties>('log', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: LogNodeProperties): [NodeDependency] {return [{target,allowPending: true,allowErrors: true,acceptNil: true,},];},run(node: LogNode, options: never, [targetValue]: [GraphNode]): NodeDefinition {const { target } = node.definition.properties;const input = target;const output = targetValue.definition;window.console.log({ input: getType(input), output: getType(output) });return target;},},},})
Const LogicNodeTypes
Logic
NodeTypes: Array<NodeType> = [AndNodeType,ChooseNodeType,EqNodeType,GtNodeType,GteNodeType,IfElseNodeType,LtNodeType,LteNodeType,NotNodeType,OrNodeType,OtherwiseNodeType,SwitchOnNodeType,WhenNodeType,]
Const LowerCaseNodeType
Lower
CaseNodeType: StatelessNodeType<"lower-case", LowerCaseNodeProperties> = createNodeType<'lower-case', LowerCaseNodeProperties>('lower-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: LowerCaseNodeProperties): Array<NodeDependency> {return [{target: subject,until: untilStringValueNode(LowerCaseNodeType, 'subject'),},];},run(node: LowerCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {return value(subject.definition.properties.value.toLowerCase());},},},})
Const LtNodeType
Lt
NodeType: StatelessNodeType<"lt", LtNodeProperties> = createNodeType<'lt',LtNodeProperties>('lt', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: LtNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Lt node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: LtNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue < rightValue);},},},})
Const LteNodeType
Lte
NodeType: StatelessNodeType<"lte", LteNodeProperties> = createNodeType<'lte',LteNodeProperties>('lte', {shape: {left: graphTypes.nodeDefinition,right: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ left, right }: LteNodeProperties): Array<NodeDependency> {return [left, right].map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Lte node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: LteNode,options: never,[left, right]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const leftValue = left.definition.properties.value;const rightValue = right.definition.properties.value;return value(leftValue <= rightValue);},},},})
Const MATCHER
MATCHER: unique symbol = Symbol.for('muster::MATCHER')
Const MATCHERS
MATCHERS: object
Type declaration
-
[id: string]: object
-
-
param: string | undefined
Const MAX_OPERATION_COUNT
MAX_OPERATION_COUNT: 9999999 = 9999999
Const MAX_STACK_SIZE
MAX_STACK_SIZE: 512 = 512
Const MISSING_PARAM_NAME
MISSING_PARAM_NAME: "$$graph-missing" = "$$graph-missing"
Const MapNodeType
Map
NodeType: StatelessNodeType<"map", MapNodeProperties> = createNodeType('map', {shape: {transform: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ transform }: MapNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => {const transformItem = fuzzyTraverse(transform, callOperation([item]));return resolveShallow(transformItem);});},run(node: MapNode,operation: TransformItemsOperation,items: Array<GraphNode>,): NodeDefinition {return nodeList(items);},},init: {run(node: MapNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;if (!next) {return error('Map reducer cannot be used as a base reducer');}return createGraphAction(next, init());},},step: {run(node: MapNode, operation: StepOperation<any>): NodeDefinition | GraphAction {const { acc, item, next } = operation.properties;if (!next) {return error('Map reducer cannot be used as a base reducer');}const { transform } = node.definition.properties;const transformedItem = apply([item], transform);return createGraphAction(next, step(acc, withScopeFrom(node, transformedItem)));},},result: {run(node: MapNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Map reducer cannot be used as a base reducer');}return createGraphAction(next, result(acc));},},},})
Const MatchPatternNodeType
Match
PatternNodeType: StatelessNodeType<"match-pattern", MatchPatternNodeProperties> = createNodeType<'match-pattern', MatchPatternNodeProperties>('match-pattern', {shape: {regex: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ regex, subject }: MatchPatternNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(MatchPatternNodeType, 'subject'),},{target: regex,until: untilRegexNode(MatchPatternNodeType, 'regex'),},];},run(node: MatchPatternNode,options: never,[subject, regex]: [ValueNode<string>, RegexNode],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const pattern = regex.definition.properties.pattern;const result = subjectValue.match(pattern);return result ? array(result.map(value)) : nil();},},},})
Const MaxNodeType
Max
NodeType: StatelessNodeType<"max", MaxNodeProperties> = createNodeType<'max',MaxNodeProperties>('max', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: MaxNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(MaxNodeType, 'operand'),}));},run(node: MaxNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {if (operands.length === 0) {return value(0);}return value(Math.max(...operands.map((operand) => operand.definition.properties.value)));},},},})
Const MinNodeType
Min
NodeType: StatelessNodeType<"min", MinNodeProperties> = createNodeType<'min',MinNodeProperties>('min', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: MinNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(MinNodeType, 'operand'),}));},run(node: MinNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {if (operands.length === 0) {return value(0);}return value(Math.min(...operands.map((operand) => operand.definition.properties.value)));},},},})
Const MockResponseMiddlewareNodeType
Mock
ResponseMiddlewareNodeType: StatelessNodeType<"mock-response-middleware", MockResponseMiddlewareNodeProperties> = createNodeType('mock-response-middleware', {shape: {responseFactory: types.saveHash(types.func),},operations: {request: {run(node: MockResponseMiddlewareNode, operation: RequestOperation): NodeDefinition {return node.definition.properties.responseFactory(operation.properties.query);},},},})
Const ModNodeType
Mod
NodeType: StatelessNodeType<"mod", ModNodeProperties> = createNodeType<'mod',ModNodeProperties>('mod', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: ModNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(ModNodeType, 'operand'),}));},run(node: ModNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {assertEnoughOperands(operands);const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total % value));},},},})
Const MultiplyNodeType
Multiply
NodeType: StatelessNodeType<"multiply", MultiplyNodeProperties> = createNodeType<'multiply', MultiplyNodeProperties>('multiply', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: MultiplyNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(MultiplyNodeType, 'operand'),}));},run(node: MultiplyNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total * value, 1));},},},})
Const NODE_DEFINITION
NODE_DEFINITION: unique symbol = Symbol.for('muster::NODE_DEFINITION')
Const NODE_MAP_MATCHER
NODE_
MAP_MATCHER: Matcher<object, Matcher<NodeDefinition<any, any, any, object, any, StaticNodeType<any, any, any> | StatelessNodeType<any, any, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<any, any, any, object, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, any>> = types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.proxiedNode]),)
Const NODE_TYPE
NODE_TYPE: unique symbol = Symbol.for('muster::NODE_TYPE')
Const NOT_FOUND
NOT_FOUND: "NOT_FOUND" = "NOT_FOUND"
Const NilNodeType
Nil
NodeType: StatelessNodeType<"nil"> = createNodeType<'nil'>('nil', {operations: {evaluate: {run(): NodeDefinition {return value(undefined);},},[WILDCARD_OPERATION]: {run(node: NilNode): GraphNode {return node;},},},})
Const NodeListNodeType
Node
ListNodeType: StatelessNodeType<"nodeList", NodeListNodeProperties> = createNodeType<'nodeList', NodeListNodeProperties>('nodeList', {shape: {items: types.arrayOf(graphTypes.graphNode),},operations: {getItems: {getDependencies(properties: NodeListNodeProperties,operation: GetItemsOperation,): Array<NodeDependency> {const { transforms } = operation.properties;return transforms.length === 0? []: [{target: transforms[0],until: untilSupportsTransformItemsOperation,},];},run(node: NodeListNode,operation: GetItemsOperation,[firstTransform]: [GraphNode],): NodeDefinition | GraphNode {const { items } = node.definition.properties;const { transforms } = operation.properties;if (transforms.length === 0) {return node;}const remainingTransforms = transforms.slice(1);return resolve([{target: traverse(firstTransform, transformItems(items)),until: untilSupportsGetItemsOperation,},],([transformedItems]: [ListGraphNode]) =>remainingTransforms.length === 0? transformedItems: createGraphAction(transformedItems, getItemsOperation(remainingTransforms)),);},},iterate: {run(node: NodeListNode): NodeDefinition {const { items } = node.definition.properties;if (items.length === 0) {return nil();}return iteratorResult(items[0], nodeList(items.slice(1)));},},length: {run(node: NodeListNode): NodeDefinition {return value(node.definition.properties.items.length);},},},})
Const NotNodeType
Not
NodeType: StatelessNodeType<"not", NotNodeProperties> = createNodeType<'not',NotNodeProperties>('not', {shape: {condition: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ condition }: NotNodeProperties): Array<NodeDependency> {return [{target: condition,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Not node condition must resolve to a value() node',{expected: ValueNodeType,received: node.definition,},);},},},];},run(node: NotNode, options: never, [condition]: [ValueNode<any>]): NodeDefinition {return value(!condition.definition.properties.value);},},},})
Const NthItemNodeType
Nth
ItemNodeType: StatelessNodeType<"nthItem", NthItemNodeProperties> = createNodeType('nthItem',{shape: {index: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ index }: NthItemNodeProperties): Array<NodeDependency> {return [{target: index,until: untilIsPositiveIntegerValueNode,},];},run(node: NthItemNode,operation: TransformItemsOperation,[index]: [ValueNode<number>],): NodeDefinition {const { value: indexValue } = index.definition.properties;return nodeList(operation.properties.items.slice(indexValue, indexValue + 1));},},init: {run(node: NthItemNode): NodeDefinition {return value(0);},},step: {getDependencies({ index }: NthItemNodeProperties): Array<NodeDependency> {return [{target: index,until: untilIsPositiveIntegerValueNode,},];},run(node: NthItemNode,operation: StepOperation<number>,[target]: [ValueNode<number>],): NodeDefinition {const { acc, item } = operation.properties;const { value: targetIndex } = target.definition.properties;const currentIndex = acc;if (currentIndex === targetIndex) {return done(value(item));}return value(currentIndex + 1);},},result: {run(node: NthItemNode, operation: ResultOperation<number | GraphNode>): NodeDefinition {const { acc, next } = operation.properties;const finalValue = nodeList(isGraphNode(acc) ? [acc] : []);return next ? value(transduce(finalValue, [next])) : value(finalValue);},},},},)
Const OPERATION_TYPE
OPERATION_TYPE: unique symbol = Symbol.for('muster::OPERATION_TYPE')
Const OnGlobalEventDebouncedNodeType
On
GlobalEventDebouncedNodeType: StatefulNodeType<"on-global-event-debounced", OnGlobalEventDebouncedNodeProperties, OnGlobalEventDebouncedState, OnGlobalEventDebouncedData> = createNodeType<'on-global-event-debounced',OnGlobalEventDebouncedNodeProperties,OnGlobalEventDebouncedState,OnGlobalEventDebouncedData>('on-global-event-debounced', {shape: {delay: types.number,eventType: types.oneOfType([types.string, types.symbol]),factory: types.saveHash(types.func),},state: {currentValue: graphTypes.nodeDefinition,},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {run(node: OnGlobalEventDebouncedNode,operation: never,dependencies: never,context: never,state: OnGlobalEventDebouncedState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<OnGlobalEventDebouncedState, OnGlobalEventDebouncedData>,node: OnGlobalEventDebouncedNode,): void {const { delay, eventType, factory } = node.definition.properties;const debouncedCallback = debounce(() => {this.setState((state) => ({...state,currentValue: factory(),}));}, delay);this.setData({disposeGlobalEventListener: node.scope.globalEvents.listen((event) => {if (event.type !== eventType) return;debouncedCallback();}),});},onUnsubscribe(this: NodeExecutionContext<OnGlobalEventDebouncedState, OnGlobalEventDebouncedData>,): void {const { disposeGlobalEventListener } = this.getData();disposeGlobalEventListener && disposeGlobalEventListener();},},},})
Const OnGlobalEventNodeType
On
GlobalEventNodeType: StatefulNodeType<"on-global-event", OnGlobalEventNodeProperties, OnGlobalEventState, OnGlobalEventData> = createNodeType<'on-global-event',OnGlobalEventNodeProperties,OnGlobalEventState,OnGlobalEventData>('on-global-event', {shape: {eventType: types.oneOfType([types.string, types.symbol]),factory: types.saveHash(types.func),},state: {currentValue: graphTypes.nodeDefinition,},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {run(node: OnGlobalEventNode,operation: never,dependencies: never,context: never,state: OnGlobalEventState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<OnGlobalEventState, OnGlobalEventData>,node: OnGlobalEventNode,): void {const { eventType, factory } = node.definition.properties;this.setData({disposeGlobalEventListener: node.scope.globalEvents.listen((event) => {if (event.type !== eventType) return;this.setState((state) => ({...state,currentValue: factory(),}));}),});},onUnsubscribe(this: NodeExecutionContext<OnGlobalEventState, OnGlobalEventData>): void {const { disposeGlobalEventListener } = this.getData();disposeGlobalEventListener && disposeGlobalEventListener();},},},})
Const OnNodeType
On
NodeType: StatefulNodeType<"on", OnNodeProperties, OnNodeState> = createNodeType<'on',OnNodeProperties,OnNodeState>('on', {state: {currentValue: types.optional(graphTypes.nodeDefinition),},shape: {initialValue: graphTypes.nodeDefinition,callback: types.saveHash(types.func),},getInitialState(): OnNodeState {return {currentValue: undefined,};},operations: {evaluate: {run(node: OnNode,options: never,dependencies: Array<never>,context: Array<never>,state: OnNodeState,): NodeDefinition {const { currentValue } = state;return currentValue || node.definition.properties.initialValue;},onSubscribe(node: OnNode) {const { callback } = node.definition.properties;const { subscription: existingSubscription } = this.getData();if (existingSubscription) {existingSubscription();}const subscription = node.scope.events.listen((event) => {const updatedValue = callback(event, getParams(node.context));if (updatedValue) {this.setState((prevState) => ({...prevState,currentValue: updatedValue,}));}});this.setData({subscription,});},onUnsubscribe(node: OnNode) {const { subscription: existingSubscription } = this.getData();if (existingSubscription) {existingSubscription();}},},reset: {run(node: OnNode,options: never,dependencies: Array<never>,context: Array<never>,state: OnNodeState,): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<OnNodeState, OnNodeData>, node: OnNode): void {const { currentValue: previousValue } = this.getState();if (!previousValue) {return;}this.setState((prevState) => ({...prevState,currentValue: undefined,}));},},},})
Const OnStreamEmissionNodeType
On
StreamEmissionNodeType: StatefulNodeType<"on-stream-emission", OnStreamEmissionNodeProperties, OnStreamEmissionState, OnStreamEmissionData> = createNodeType<'on-stream-emission',OnStreamEmissionNodeProperties,OnStreamEmissionState,OnStreamEmissionData>('on-stream-emission', {shape: {factory: types.saveHash(types.func),stream: types.saveHash(types.any),},state: {currentValue: graphTypes.nodeDefinition,},getInitialState() {return {currentValue: pending(),};},operations: {evaluate: {run(node: OnStreamEmissionNode,operation: never,dependencies: never,context: never,state: OnStreamEmissionState,): NodeDefinition {return state.currentValue;},onSubscribe(this: NodeExecutionContext<OnStreamEmissionState, OnStreamEmissionData>,node: OnStreamEmissionNode,): void {const { factory, stream } = node.definition.properties;this.setData({streamSubscription: stream.subscribe(() => {this.setState((state) => ({...state,currentValue: factory(),}));}),});},onUnsubscribe(this: NodeExecutionContext<OnStreamEmissionState, OnStreamEmissionData>): void {const { streamSubscription } = this.getData();streamSubscription && streamSubscription.unsubscribe();},},},})
Const OnceNodeType
Once
NodeType: StatefulNodeType<"once", OnceNodeProperties, OnceNodeState, OnceNodeData> = createNodeType<'once', OnceNodeProperties, OnceNodeState, OnceNodeData>('once', {state: {currentValue: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),},shape: {target: types.oneOfType<NodeDefinition | GraphNode | NodeDependency>([graphTypes.nodeDefinition,graphTypes.graphNode,graphTypes.nodeDependency,]),},getInitialState(): OnceNodeState {return {currentValue: pending(),};},operations: {evaluate: {cacheable: false,run(node: OnceNode,options: never,dependencies: Array<never>,context: Array<never>,state: OnceNodeState,): NodeDefinition | GraphNode {const { currentValue } = state;return currentValue;},onSubscribe(node: OnceNode): void {const { target } = node.definition.properties;this.setState((prevState) => ({...prevState,currentValue: resolve([isGraphNode(target) || isNodeDefinition(target) ? { target } : target],([result]: [GraphNode]) => {this.setState((state: OnceNodeState): OnceNodeState => ({...state,currentValue: result,}),);return result;},),}));},},},})
Const OptimisticNodeType
Optimistic
NodeType: StatefulNodeType<"optimistic", OptimisticNodeProperties> = createNodeType<'optimistic', OptimisticNodeProperties>('optimistic', {shape: {target: graphTypes.nodeDefinition,},state: {pendingSetOperations: types.arrayOf(types.string),setResults: types.objectOf(graphTypes.graphNode),value: types.optional(graphTypes.graphNode),},getInitialState(): OptimisticNodeState {return {pendingSetOperations: [],setResults: {},value: undefined,};},operations: {evaluate: {run(node: OptimisticNode,operation: never,dependencies: never,context: never,state: OptimisticNodeState,): GraphNode | NodeDefinition {return state.value || node.definition.properties.target;},},isUpdating: {run(node: OptimisticNode,operation: never,dependencies: never,context: never,state: OptimisticNodeState,): NodeDefinition {return value(state.pendingSetOperations.length > 0);},},set: {run(node: OptimisticNode,operation: SetOperation,dependencies: never,context: never,state: OptimisticNodeState,): GraphNode {return state.setResults[operation.id];},onSubscribe(this: NodeExecutionContext<OptimisticNodeState, OptimisticNodeData>,node: OptimisticNode,operation: SetOperation,): void {const { target } = node.definition.properties;const nodeToResolve = withScopeFrom(node, set(target, operation.properties.value));this.setState((state) => ({...state,pendingSetOperations: [...state.pendingSetOperations, operation.id],setResults: {...state.setResults,[operation.id]: withScopeFrom(node, ok()),},value: withScopeFrom(node, operation.properties.value),}));const unsubscribe = node.scope.store.subscribe(nodeToResolve,resolveOperation(),(value) => {if (PendingNodeType.is(value)) return;this.setState((state) => ({...state,pendingSetOperations: state.pendingSetOperations.filter((id) => id !== operation.id),setResults: ErrorNodeType.is(value)? {...state.setResults,[operation.id]: value,}: state.setResults,value: ErrorNodeType.is(value) ? undefined : value,}));},);this.setData((data) => ({...data,setSubscriptions: {...data.setSubscriptions,[operation.id]: unsubscribe,},}));},onUnsubscribe(this: NodeExecutionContext<OptimisticNodeState, OptimisticNodeData>,node: OptimisticNode,operation: SetOperation,): void {const unsubscribe = this.getData().setSubscriptions![operation.id];unsubscribe();this.setData((data) => ({...data,setSubscriptions: omit(data.setSubscriptions, operation.id),}));this.setState((state) => ({...state,pendingSetOperations: state.pendingSetOperations.filter((id) => id !== operation.id),setResults: omit(state.setResults, operation.id),}));},},},})
Const OrNodeType
Or
NodeType: StatelessNodeType<"or", OrNodeProperties> = createNodeType<'or',OrNodeProperties>('or', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: OrNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Or node operands must resolve to value() nodes', {expected: ValueNodeType,received: node.definition,});},},}));},run(node: OrNode, options: never, operands: Array<ValueNode<any>>): NodeDefinition {return value(operands.some((operand) => Boolean(operand.definition.properties.value)));},},},})
Const OtherwiseNodeType
Otherwise
NodeType: StaticNodeType<"otherwise", OtherwiseNodeProperties> = createNodeType<'otherwise', OtherwiseNodeProperties>('otherwise', {shape: {value: graphTypes.nodeDefinition,},})
Const PARAM_NAME_PREFIX
PARAM_NAME_PREFIX: "$$param:" = "$$param:"
Const PARENT
PARENT: unique symbol = Symbol('PARENT')
Const PARENT_SCOPE_PATH_KEY
PARENT_SCOPE_PATH_KEY: unique symbol = Symbol('PARENT_SCOPE_PATH_KEY')
Const PATH_KEY
PATH_KEY: unique symbol = Symbol('PATH_KEY')
Const PENDING
PENDING: never = {} as never
Const PROXIED_NODE
PROXIED_NODE: unique symbol = Symbol('muster::PROXIED_NODE')
Const PROXIED_NODE_DEFINITION
PROXIED_NODE_DEFINITION: unique symbol = Symbol('muster::PROXIED_NODE_DEFINITION')
Const ParallelNodeType
Parallel
NodeType: StatelessNodeType<"parallel", ParallelNodeProperties> = createNodeType<'parallel', ParallelNodeProperties>('parallel', {shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {cacheable: false,getDependencies({ operations }: ParallelNodeProperties): Array<NodeDependency> {return operations.map((operation) => ({ target: operation, once: true }));},run(node: ParallelNode, options: never, dependencies: Array<GraphNode>): NodeDefinition {return array(dependencies.map((node) => node.definition));},},},})
Const ParamNodeType
Param
NodeType: StatelessNodeType<"param", ParamNodeProperties> = createNodeType<'param',ParamNodeProperties>('param', {shape: {name: types.string,},operations: {evaluate: {getContextDependencies({ name }: ParamNodeProperties): [ContextDependency] {return [{ name: getParamContextId(name), required: true, until: shallow }];},run(node: ParamNode,options: never,dependencies: Array<never>,[paramNode]: [ValueNode<ChildKey>],): GraphNode {return paramNode;},},},})
Const ParentNodeType
Parent
NodeType: StatelessNodeType<"parent"> = createNodeType<'parent'>('parent', {operations: {evaluate: {getContextDependencies(): [ContextDependency] {return [{name: PARENT,required: false,until: shallow,defaultValue: error('Cannot resolve parent of root node'),},];},run(node: ParentNode,options: never,dependencies: Array<never>,[parentNode]: [GraphNode],): GraphNode {return parentNode;},},},})
Const ParseFloatNodeType
Parse
FloatNodeType: StatelessNodeType<"parse-float", ParseFloatNodeProperties> = createNodeType<'parse-float', ParseFloatNodeProperties>('parse-float', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: ParseFloatNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ParseFloatNodeType, 'subject'),},];},run(node: ParseFloatNode,options: never,[subject]: [ValueNode<string>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;return value(Number.parseFloat(subjectValue));},},},})
Const ParseIntNodeType
Parse
IntNodeType: StatelessNodeType<"parse-int", ParseIntNodeProperties> = createNodeType<'parse-int', ParseIntNodeProperties>('parse-int', {shape: {radix: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ radix, subject }: ParseIntNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ParseIntNodeType, 'subject'),},{target: radix,until: untilPositiveIntegerValueNode(ParseIntNodeType, 'radix'),},];},run(node: ParseIntNode,options: never,[subject, radix]: [ValueNode<string>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const radixValue = radix.definition.properties.value;return value(Number.parseInt(subjectValue, radixValue));},},},})
Const PartialNodeType
Partial
NodeType: StatelessNodeType<"partial", PartialNodeProperties> = createNodeType<'partial',PartialNodeProperties>('partial', {shape: {args: types.oneOfType([types.objectOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),types.arrayOf(types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])),]),target: graphTypes.nodeDefinition,},operations: {call: {getDependencies({ target }: PartialNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsCallOperation,},];},run(node: PartialNode,operation: CallOperation,[target]: [GraphNode],): NodeDefinition | GraphAction {const { args } = node.definition.properties;const { args: inputArgs } = operation.properties;if (isCallArgumentMap(args)) {// Handle the named arguments mapif (inputArgs && !isCallArgumentMap(inputArgs)) {return error(getInvalidTypeError('A partial node was called with unexpected type of arguments.', {expected: 'Named arguments',received: 'Array of arguments',}),);}const combinedArgs = inputArgs ? { ...inputArgs, ...args } : args;const argsGraphNodes = mapValues(combinedArgs, (arg) =>isGraphNode(arg) ? arg : withScopeFrom(node, arg),);return createGraphAction(target, callOperation(argsGraphNodes));}// Handle the positional argumentsif (inputArgs && !isCallArgumentArray(inputArgs)) {return error(getInvalidTypeError('A partial node was called with unexpected type of arguments.', {expected: 'Array of arguments',received: 'Named arguments',}),);}const combinedArgs = inputArgs ? [...args, ...inputArgs] : args;const argsGraphNodes = combinedArgs.map((arg) =>isGraphNode(arg) ? arg : withScopeFrom(node, arg),);return createGraphAction(target, callOperation(argsGraphNodes));},},},})
Const PendingNodeType
Pending
NodeType: StaticNodeType<"pending"> = createNodeType<'pending'>('pending')
Const PlaceholderNodeType
Placeholder
NodeType: StatefulNodeType<"placeholder", PlaceholderNodeProperties, PlaceholderNodeState, PlaceholderNodeData> = createNodeType<'placeholder',PlaceholderNodeProperties,PlaceholderNodeState,PlaceholderNodeData>('placeholder', {state: {results: types.objectOf(graphTypes.nodeDefinition),},shape: {path: types.arrayOf(types.shape({id: types.string,operation: graphTypes.graphOperation,}),),queryBuilder: types.saveHash(types.any),},serialize: false,deserialize: false,getInitialState(): PlaceholderNodeState {return {results: {},};},operations: {[WILDCARD_OPERATION]: {run(node: PlaceholderNode,operation: GraphOperation,dependencies: never,context: never,state: PlaceholderNodeState,): NodeDefinition | GraphNode {return state.results[operation.id] || pending();},onSubscribe(this: NodeExecutionContext<PlaceholderNodeState, PlaceholderNodeData>,node: PlaceholderNode,operation: GraphOperation,): void {const { path, queryBuilder } = node.definition.properties;const resultNode = stateful<NodeDefinition | GraphNode>(pending());const getOperationDependencies = (): Array<NodeDependency> | undefined => {if (isCallOperation(operation)) {const { args } = operation.properties;if (!args) return [];if (Array.isArray(args)) {return args.map((arg) => ({target: arg,once: true,}));}return Object.keys(args).map((name) => ({target: args[name],once: true,}));}if (isGetItemsOperation(operation)) {return operation.properties.transforms.map((transform) => {const transformNode = isNodeDefinition(transform)? withScopeFrom(node, transform): transform;const resolveTransform = hoistDependencies(transformNode);return { target: resolveTransform.definition };});}return undefined;};let lastResolvedDependenciesIds: Array<string> | undefined;const dependenciesResolved = (resolvedDependencies: Array<GraphNode>): NodeDefinition => {if (lastResolvedDependenciesIds) {const dependenciesHaveChanged = lastResolvedDependenciesIds.some((id, index) => id !== resolvedDependencies[index].id,);if (!dependenciesHaveChanged) {queryBuilder.markAsModified();return resultNode;}}lastResolvedDependenciesIds = resolvedDependencies.map(({ id }) => id);if (isCallOperation(operation)) {const { args } = operation.properties;const argsValues = toNodeDefinitionArray(resolvedDependencies);let resolvedOperation: CallOperation;if (!args) {resolvedOperation = callOperation();} else if (isCallArgumentArray(args)) {// Handle the array of argumentsresolvedOperation = callOperation(argsValues);} else {// Handle the named argumentsresolvedOperation = callOperation(fromPairs(zip(Object.keys(args), argsValues)));}const childPath = [...path, { id: operation.id, operation: resolvedOperation }];const disposeRequest = queryBuilder.addRequest(childPath, (result) =>resultNode.update(assignPlaceholderPath(node, path, result)),);this.setData((data) => ({...data,disposeRequest: {...data.disposeRequest,[operation.id]: disposeRequest,},}));} else if (isGetChildOperation(operation)) {const childPath = [...path, { id: operation.id, operation }];const dispose = queryBuilder.addRequest(childPath);this.setData((data) => ({...data,disposeRequest: {...data.disposeRequest,[operation.id]: dispose,},}));return placeholder(queryBuilder, childPath);} else if (isGetItemsOperation(operation)) {const data = this.getData();const disposePreviousGetItems =data.disposeRequest && data.disposeRequest[operation.id];if (disposePreviousGetItems) {disposePreviousGetItems();}const operationWithResolvedTransforms = getItemsOperation(toNodeDefinitionArray(resolvedDependencies),);const childPath = [...path,{ id: operation.id, operation: operationWithResolvedTransforms },];const dispose = queryBuilder.addRequest(childPath, (result) => {resultNode.update(assignPlaceholderPath(node, path, result));});this.setData((data) => ({...data,disposeRequest: {...data.disposeRequest,[operation.id]: dispose,},}));resultNode.update(placeholder(queryBuilder, childPath));} else if (isIterateOperation(operation)) {const childPath = [...path, { id: operation.id, operation: getItemsOperation() }];resultNode.update(placeholder(queryBuilder, childPath));const dispose = queryBuilder.addRequest(childPath, (result) => {resultNode.update(assignPlaceholderPath(node, path, toIteratorResult(result)));});this.setData((data) => ({...data,disposeRequest: {...data.disposeRequest,[operation.id]: dispose,},}));} else if (isSetOperation(operation)) {this.setData((data) => ({...data,disposeRequest: {...data.disposeRequest,[operation.id]: queryBuilder.addRequest([...path, { id: operation.id, operation }],(result) => {resultNode.update(assignPlaceholderPath(node,path,isOkNodeDefinition(result) ? operation.properties.value : result,),);},),},}));} else {this.setData((data) => ({...data,disposeRequest: {...data.disposeRequest,[operation.id]: queryBuilder.addRequest([...path, { id: operation.id, operation }],(result) => {resultNode.update(assignPlaceholderPath(node, path, result));},),},}));}return resultNode;};const dependencies = getOperationDependencies();if (dependencies && dependencies.length > 0) {this.setState((state) => ({...state,results: {...state.results,[operation.id]: resolve(dependencies, dependenciesResolved),},}));} else {this.setState((state) => ({...state,results: {...state.results,[operation.id]: dependenciesResolved([]),},}));}},onInvalidate(this: NodeExecutionContext<PlaceholderNodeState, PlaceholderNodeData>,node: PlaceholderNode,operation: GraphOperation,): void {if (!isEvaluateOperation(operation)) return;const results = this.getState().results;const { path, queryBuilder } = node.definition.properties;const resultNode =results && results[operation.id]? (results[operation.id] as ExternalStatefulNodeDefinition<NodeDefinition | GraphNode>): stateful<NodeDefinition | GraphNode>(pending());this.setData((data) => ({...data,disposeRequest: {...data.disposeRequest,[operation.id]: queryBuilder.addRequest([...path, { id: operation.id, operation }],(result) => {resultNode.update(assignPlaceholderPath(node, path, result));},),},}));this.setState((state) => ({...state,results: {...state.results,[operation.id]: resultNode,},}));},onUnsubscribe(this: NodeExecutionContext<PlaceholderNodeState, PlaceholderNodeData>,node: PlaceholderNode,operation: GraphOperation,): void {const { disposeRequest } = this.getData();const disposeCurrentRequest = disposeRequest && disposeRequest[operation.id];if (disposeCurrentRequest) {disposeCurrentRequest();this.setData((data) => ({...data,disposeRequest: omit(data.disposeRequest, operation.id),}));}this.setState((state) => ({...state,results: omit(state.results, operation.id),}));},},},})
Const PopNodeType
Pop
NodeType: StatefulNodeType<"pop", PopNodeProperties, PopNodeState, __type> = createNodeType<'pop', PopNodeProperties, PopNodeState, {}>('pop', {shape: {id: types.number,target: graphTypes.nodeDefinition,},state: {currentValue: types.optional(graphTypes.nodeDefinition),},getInitialState() {return {currentValue: undefined,};},operations: {evaluate: {cacheable: false,run(node: PopNode,options: never,dependencies: never,context: never,state: PopNodeState,): GraphNode {return state.currentValue!;},onSubscribe(this: NodeExecutionContext<PopNodeState, {}>, node: PopNode): void {if (this.getState().currentValue) return;const { target } = node.definition.properties;this.setState(() => ({currentValue: withScopeFrom(node,resolve([{ target, until: untilSupportsPopOperation }], ([resolvedTarget]) => {return withScopeFrom(resolvedTarget,resolve([createGraphAction(resolvedTarget, popOperation())], ([result]) => {this.setState(() => ({ currentValue: result }));return result;}),);}),),}));},},},})
Const PopOperationType
Pop
OperationType: OperationType<"pop", PopProperties> = createOperationType<'pop',PopProperties>('pop', {cacheable: false,shape: {},})
Const PowNodeType
Pow
NodeType: StatelessNodeType<"pow", PowNodeProperties> = createNodeType<'pow',PowNodeProperties>('pow', {shape: {base: graphTypes.nodeDefinition,exponent: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ base, exponent }: PowNodeProperties): Array<NodeDependency> {return [{target: base,until: untilNumberValueNode(PowNodeType, 'base'),},{target: exponent,until: untilNumberValueNode(PowNodeType, 'exponent'),},];},run(node: PowNode,options: never,[base, exponent]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {return value(Math.pow(base.definition.properties.value, exponent.definition.properties.value),);},},},})
Const PropertyNodeType
Property
NodeType: StatelessNodeType<"property", PropertyNodeProperties> = createNodeType<'property', PropertyNodeProperties>('property', {shape: {subject: graphTypes.nodeDefinition,path: types.arrayOf(types.string),},operations: {evaluate: {getDependencies({ subject }: PropertyNodeProperties): Array<NodeDependency> {return [{target: subject,until: {predicate: ValueNodeType.is,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage('Property node subject must resolve to a value() node',{expected: ValueNodeType,received: node.definition,},);},},},];},run(node: PropertyNode,options: never,[subjectNode]: [ValueNode<any>],): NodeDefinition | GraphNode {const { path } = node.definition.properties;const subject = subjectNode.definition.properties.value;return value(getPath(subject, path));},},},})
Const ProxyNodeType
Proxy
NodeType: StatelessNodeType<"proxy", ProxyNodeProperties> = createNodeType<'proxy',ProxyNodeProperties>('proxy', {shape: {middlewares: types.arrayOf(graphTypes.nodeDefinition),queryBuilder: types.saveHash(types.any),schedulerFactory: types.saveHash(types.func),},serialize: false,deserialize: false,operations: {evaluate: {run(node: ProxyNode): NodeDefinition {const { middlewares, queryBuilder, schedulerFactory } = node.definition.properties;const composedMiddleware = composeMiddlewares(transformMiddlewares(middlewares, node));let lastResult: NodeDefinition = ok();let lastSnapshot: QueriesSnapshot | undefined = undefined;return takeLast([schedulerFactory(() => {if (!queryBuilder.isModified) return lastResult;queryBuilder.resetModifiedState();const queryBuilderSnapshot = getQueryBuilderSnapshot(queryBuilder);if (lastSnapshot && isEqual(lastSnapshot, queryBuilderSnapshot)) return lastResult;lastSnapshot = queryBuilderSnapshot;const querySetWithCallback = buildQuerySetFromQueryBuilderSnapshot(queryBuilderSnapshot,queryBuilder,);const traverseRequest = traverse(composedMiddleware,requestOperation(querySetWithCallback.node, {}),);lastResult = resolve([{ target: traverseRequest, allowErrors: true }],([result]: [GraphNode]) => {querySetWithCallback.callback(result.definition);return ok();},);return lastResult;}),placeholder(queryBuilder, []),]);},},},})
Const PushNodeType
Push
NodeType: StatefulNodeType<"push", PushNodeProperties, PushNodeState, __type> = createNodeType<'push', PushNodeProperties, PushNodeState, {}>('push', {shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, item: NodeDefinition) =>createGraphAction(target, pushOperation(item)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target }: PushNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsPushOperation,},];},run(node: PushNode,options: never,[target]: [GraphNode],context: never,state: PushNodeState,): GraphAction {return state.memoized(target, node.definition.properties.item);},},},})
Const PushOperationType
Push
OperationType: OperationType<"push", PushProperties> = createOperationType<'push',PushProperties>('push', {cacheable: false,shape: {value: graphTypes.nodeDefinition,},})
Const QueryNodeType
Query
NodeType: StatefulNodeType<"query", QueryNodeProperties> = createNodeType<'query',QueryNodeProperties,QueryNodeState,QueryNodeData>('query', {shape: {keys: graphTypes.nodeDefinition,root: graphTypes.nodeDefinition,},state: {result: types.oneOfType([graphTypes.graphNode, graphTypes.nodeDefinition]),},getInitialState(): QueryNodeState {return {result: pending(),};},operations: {evaluate: {run(node: QueryNode,operation: never,dependencies: never,context: never,state: QueryNodeState,): NodeDefinition | GraphNode {return state.result;},onSubscribe(this: NodeExecutionContext<QueryNodeState, QueryNodeData>,node: QueryNode,): void {let previousResponse: NodeDefinition | undefined;try {const { keys, root } = node.definition.properties;const { querySet, responseAssembler } = buildQuerySetForQuery(root, keys);this.setData({disposeQuerySetSubscription: node.scope.store.subscribe(withScopeFrom(node, querySet),resolveOperation(),(response) => {if (ErrorNodeType.is(response) || PendingNodeType.is(response)) {this.setState({result: response,});return;}const newResponse = safelyGetValueFromResponse(response, responseAssembler);if (previousResponse && newResponse.type === previousResponse.type) {if (isValueNodeDefinition(newResponse) &&isValueNodeDefinition(previousResponse) &&isEqual(newResponse.properties.value, previousResponse.properties.value)) {return;}}previousResponse = newResponse;this.setState({result: newResponse,});},),});} catch (ex) {this.setState({result: isErrorNodeDefinition(ex) ? ex : error(ex),});}},onUnsubscribe(this: NodeExecutionContext<QueryNodeState, QueryNodeData>): void {const { disposeQuerySetSubscription } = this.getData();disposeQuerySetSubscription && disposeQuerySetSubscription();},},},})
Const QuerySetCallOperationNodeType
Query
SetCallOperationNodeType: StatelessNodeType<"query-set-call-operation", QuerySetCallOperationNodeProperties> = createNodeType<'query-set-call-operation', QuerySetCallOperationNodeProperties>('query-set-call-operation',{shape: {operation: graphTypes.graphOperation,},operations: {},},)
Const QuerySetCatchErrorNodeType
Query
SetCatchErrorNodeType: StaticNodeType<"query-set-catch-error", QuerySetCatchErrorNodeProperties> = createNodeType<'query-set-catch-error', QuerySetCatchErrorNodeProperties>('query-set-catch-error',{deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},},)
Const QuerySetDeferNodeType
Query
SetDeferNodeType: StaticNodeType<"query-set-defer", QuerySetDeferNodeProperties> = createNodeType<'query-set-defer', QuerySetDeferNodeProperties>('query-set-defer', {deserialize: false,serialize: false,shape: {fallbackGenerator: types.saveHash(types.func),target: graphTypes.nodeDefinition,},})
Const QuerySetGetChildOperationNodeType
Query
SetGetChildOperationNodeType: StaticNodeType<"query-set-get-child-operation", QuerySetGetChildOperationNodeProperties> = createNodeType<'query-set-get-child-operation', QuerySetGetChildOperationNodeProperties>('query-set-get-child-operation',{shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),operation: graphTypes.graphOperation,},},)
Const QuerySetGetItemsOperationNodeType
Query
SetGetItemsOperationNodeType: StaticNodeType<"query-set-get-items-operation", QuerySetGetItemsOperationNodeProperties> = createNodeType<'query-set-get-items-operation', QuerySetGetItemsOperationNodeProperties>('query-set-get-items-operation',{shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),operation: graphTypes.graphOperation,},},)
Const QuerySetIsPendingNodeType
Query
SetIsPendingNodeType: StaticNodeType<"query-set-is-pending", QuerySetIsPendingNodeProperties> = createNodeType<'query-set-is-pending', QuerySetIsPendingNodeProperties>('query-set-is-pending',{deserialize: false,serialize: false,shape: {target: graphTypes.nodeDefinition,},},)
Const QuerySetNodeType
Query
SetNodeType: StatelessNodeType<"query-set", QuerySetNodeProperties> = createNodeType<'query-set', QuerySetNodeProperties>('query-set', {shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),options: types.shape({bubbleErrorsToTop: types.bool,}),root: graphTypes.nodeDefinition,},operations: {evaluate: {run(node: QuerySetNode): NodeDefinition {const { children, options, root } = node.definition.properties;return resolveOperations(withScopeFrom(node, root), children, withScopeFrom(node,value(options),) as ValueNode<QuerySetOptions>);},},},})
Const QuerySetOperationNodeType
Query
SetOperationNodeType: StaticNodeType<"query-set-operation", QuerySetOperationNodeProperties> = createNodeType<'query-set-operation', QuerySetOperationNodeProperties>('query-set-operation', {shape: {children: types.optional(types.arrayOf(graphTypes.nodeDefinition)),operation: graphTypes.graphOperation,},})
Const QuerySetResultNodeType
Query
SetResultNodeType: StatefulNodeType<"query-set-result", QuerySetResultNodeProperties, QuerySetResultNodeState, QuerySetResultNodeData> = createNodeType<'query-set-result',QuerySetResultNodeProperties,QuerySetResultNodeState,QuerySetResultNodeData>('query-set-result', {shape: {queries: types.arrayOf(graphTypes.nodeDefinition),result: graphTypes.nodeDefinition,},state: {},getInitialState() {return {};},operations: {call: {run(node: QuerySetResultNode, operation: CallOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetCallOperationNodeDefinition(query) &&query.properties.operation.id === operation.id,);if (queryIndex === -1) {return error(`Could not find 'call' result for operation: ${operation.id}`);}const query = queries[queryIndex] as QuerySetOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},evaluate: {run(node: QuerySetResultNode): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetOperationNodeDefinition(query) &&(isEvaluateOperation(query.properties.operation) ||isResolveOperation(query.properties.operation)),);if (queryIndex === -1) {return error('Node does not support `evaluate` operation.');}const query = queries[queryIndex] as QuerySetOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},getChild: {run(node: QuerySetResultNode, operation: GetChildOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetGetChildOperationNodeDefinition(query) &&query.properties.operation.id === operation.id,);if (queryIndex === -1) {const { key } = operation.properties;return notFound(`Could not find 'getChild' result for key: ${getType(key)}`);}const query = queries[queryIndex] as QuerySetGetChildOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},getItems: {run(node: QuerySetResultNode, operation: GetItemsOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetGetItemsOperationNodeDefinition(query) &&(query.properties.operation? query.properties.operation.id === operation.id: operation.properties.transforms.length === 0),);if (queryIndex === -1) {return error(`Could not find 'getItems' result for operation: ${operation.id}.`);}const query = queries[queryIndex] as QuerySetGetItemsOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},set: {run(node: QuerySetResultNode, operation: CallOperation): NodeDefinition {const { queries, result } = node.definition.properties;const queryIndex = queries.findIndex((query) =>isQuerySetSetOperationNodeDefinition(query) &&query.properties.operation.id === operation.id,);if (queryIndex === -1) {return error(`Could not find 'set' result for operation: ${operation.id}`);}const query = queries[queryIndex] as QuerySetGetItemsOperationNodeDefinition;const queryResult = result.properties.items[queryIndex];if (!query.properties.children) {return queryResult;}if (!isArrayNodeDefinition(queryResult)) {return error(getInvalidTypeErrorMessage('Invalid query result', {expected: ArrayNodeType,received: queryResult,}),);}return querySetResult(query.properties.children, queryResult);},},},})
Const QuerySetSetOperationNodeType
Query
SetSetOperationNodeType: StatelessNodeType<"query-set-set-operation", QuerySetSetOperationNodeProperties> = createNodeType<'query-set-set-operation', QuerySetSetOperationNodeProperties>('query-set-set-operation',{shape: {operation: graphTypes.graphOperation,},operations: {},},)
Const ROOT_CONTEXT_NAME
ROOT_CONTEXT_NAME: unique symbol = Symbol('ROOT')
Const ReduceNodeType
Reduce
NodeType: StatelessNodeType<"reduce", ReduceNodeProperties> = createNodeType<'reduce',ReduceNodeProperties>('reduce', {shape: {source: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),reducer: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),initialState: types.any,},operations: {evaluate: {getDependencies({ source }: ReduceNodeProperties): Array<NodeDependency> {return [{target: source,until: untilSupportsIterateOperation,},];},run(node: ReduceNode, options: never, [iterable]: [GraphNode]): NodeDefinition {const { initialState, reducer } = node.definition.properties;return getNextIteratorResult(iterable, (iteratorResult) => {if (NilNodeType.is(iteratorResult)) {return withScopeFrom(iterable, value(initialState));}const { value: itemValue, next: nextIterator } = iteratorResult.definition.properties;const item = isGraphNode(itemValue)? itemValue: withScopeFrom(iteratorResult, itemValue);return withScopeFrom(iteratorResult,applyReducerStep(reducer, initialState, item, (transformedResult) => {if (DoneNodeType.is(transformedResult)) {const resultValue = transformedResult.definition.properties.value!;return withScopeFrom(transformedResult,resolve([{target: resultValue,until: untilValidReducerStep,},],([finalValue]: [ValueNode<any>]) => finalValue,),);}const { value: updatedState } = transformedResult.definition.properties;if (!nextIterator) {return withScopeFrom(transformedResult, value(updatedState));}const nextIteratorNode = isGraphNode(nextIterator)? nextIterator: withScopeFrom(iteratorResult, nextIterator);const nextResult = reduce(nextIteratorNode, reducer, updatedState);return withScopeFrom(node, nextResult);}),);});},},},})
Const RegexNodeType
Regex
NodeType: StaticNodeType<"regex", RegexNodeProperties, SerializedRegexNodeProperties> = createNodeType<'regex', RegexNodeProperties, SerializedRegexNodeProperties>('regex', {shape: {pattern: types.oneOfType([types.string, types.saveHash(types.any)]),},serialize(properties: RegexNodeProperties): SerializedRegexNodeProperties {return {pattern: { source: properties.pattern.source, flags: properties.pattern.flags },};},deserialize(properties: SerializedRegexNodeProperties): RegexNodeProperties {return {pattern: new RegExp(properties.pattern.source, properties.pattern.flags),};},})
Const RemoteMiddlewareNodeTypes
Remote
MiddlewareNodeTypes: Array<NodeType> = [// CacheMiddlewareNodeType,CombinedMiddlewareNodeType,FromStreamMiddlewareNodeType,MockResponseMiddlewareNodeType,TransformResponseMiddlewareNodeType,XhrMiddlewareNodeType,]
Const RemoteNodeTypes
Remote
NodeTypes: Array<NodeType> = [...RemoteMiddlewareNodeTypes, ProxyNodeType]
Const RemoveItemAtNodeType
Remove
ItemAtNodeType: StatefulNodeType<"remove-item-at", RemoveItemAtNodeProperties, RemoveItemAtNodeState, __type> = createNodeType<'remove-item-at', RemoveItemAtNodeProperties, RemoveItemAtNodeState, {}>('remove-item-at',{shape: {index: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, index: number) =>createGraphAction(target, removeItemAtOperation(index)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, index }: RemoveItemAtNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsRemoveItemAtOperation,},{target: index,until: untilPositiveValueIndex,},];},run(node: RemoveItemAtNode,options: never,[target, index]: [GraphNode, ValueNode<number>],context: never,state: RemoveItemAtNodeState,): GraphAction {return state.memoized(target, index.definition.properties.value);},},},},)
Const RemoveItemAtOperationType
Remove
ItemAtOperationType: OperationType<"removeItemAt", RemoveItemAtProperties> = createOperationType<'removeItemAt', RemoveItemAtProperties>('removeItemAt', {cacheable: false,shape: {index: types.number,},})
Const RemoveItemNodeType
Remove
ItemNodeType: StatefulNodeType<"remove-item", RemoveItemNodeProperties, RemoveItemNodeState, __type> = createNodeType<'remove-item', RemoveItemNodeProperties, RemoveItemNodeState, {}>('remove-item',{shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: lodashOnce((target: GraphNode, id: string) =>createGraphAction(target, removeItemOperation(id)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, item }: RemoveItemNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsRemoveItemOperation,},{target: once({target: item,until: untilItemWithId,}),until: untilItemWithId,},];},run(node: RemoveItemNode,options: never,[target, item]: [GraphNode, ItemWithIdNode],context: never,state: RemoveItemNodeState,): GraphAction {return state.memoized(target, item.definition.properties.id);},},},},)
Const RemoveItemOperationType
Remove
ItemOperationType: OperationType<"removeItem", RemoveItemProperties> = createOperationType<'removeItem', RemoveItemProperties>('removeItem', {cacheable: false,shape: {id: types.string,},})
Const RemoveItemsNodeType
Remove
ItemsNodeType: StatefulNodeType<"remove-items", RemoveItemsNodeProperties, RemoveItemsNodeState, __type> = createNodeType<'remove-items', RemoveItemsNodeProperties, RemoveItemsNodeState, {}>('remove-items',{shape: {predicate: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, predicate: NodeDefinition) =>createGraphAction(target, removeItemsOperation(predicate)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target, predicate }: RemoveItemsNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsRemoveItemsOperation,},];},run(node: RemoveItemsNode,operation: never,[target]: [GraphNode],context: never,state: RemoveItemsNodeState,): GraphAction {const { predicate } = node.definition.properties;return state.memoized(target, predicate);},},},},)
Const RemoveItemsOperationType
Remove
ItemsOperationType: OperationType<"removeItems", RemoveItemsProperties> = createOperationType<'removeItems', RemoveItemsProperties>('removeItems', {cacheable: false,shape: {predicate: graphTypes.nodeDefinition,},})
Const ReplaceNodeType
Replace
NodeType: StatelessNodeType<"replace", ReplaceNodeProperties> = createNodeType<'replace',ReplaceNodeProperties>('replace', {shape: {pattern: graphTypes.nodeDefinition,replacePattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({pattern,replacePattern,subject,}: ReplaceNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ReplaceNodeType, 'subject'),},{target: pattern,until: untilStringValueNode(ReplaceNodeType, 'pattern'),},{target: replacePattern,until: untilStringValueNode(ReplaceNodeType, 'replacePattern'),},];},run(node: ReplaceNode,options: never,[subject, pattern, replacePattern]: Array<ValueNode<string>>,): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const patternValue = pattern.definition.properties.value;const replacePatternValue = replacePattern.definition.properties.value;return value((subjectValue || '').replace(patternValue, replacePatternValue));},},},})
Const RequestOperationType
Request
OperationType: OperationType<"request", RequestProperties> = createOperationType<'request', RequestProperties>('request', {shape: {metadata: types.objectOf(types.saveHash(types.any)),next: types.optional(graphTypes.graphNode),query: graphTypes.nodeDefinition,},})
Const ResetNodeType
Reset
NodeType: StatelessNodeType<"reset", ResetNodeProperties> = createNodeType<'reset',ResetNodeProperties>('reset', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target }: ResetNodeProperties): [NodeDependency] {return [{target,until: {predicate: supportsResetOperation,errorMessage(node: GraphNode): string {return getInvalidTypeErrorMessage(`${pascalCase(ResetNodeType.name)} target cannot be reset`,{ received: node.definition },);},},},];},run(node: ResetNode, operation: never, [subjectNode]: [ResettableGraphNode]): GraphAction {return createGraphAction(subjectNode, resetOperation());},},},})
Const ResetOperationType
Reset
OperationType: OperationType<"reset"> = createOperationType('reset', {cacheable: false,})
Const ResolveOperationType
Resolve
OperationType: OperationType<"resolve", ResolveProperties> = createOperationType<'resolve', ResolveProperties>('resolve', {shape: {until: types.optional(types.shape({predicate: types.saveHash(types.func),errorMessage: types.saveHash(types.func),}),),allowErrors: types.bool,allowPending: types.bool,acceptNil: types.bool,},})
Const ResultOperationType
Result
OperationType: OperationType<"result", ResultProperties<any>> = createOperationType<'result', ResultProperties<any>>('result', {shape: {acc: types.saveHash(types.any),next: types.optional(graphTypes.graphNode),},})
Const RootNodeType
Root
NodeType: StatelessNodeType<"root"> = createNodeType<'root'>('root', {operations: {evaluate: {run(node: RootNode): GraphNode {return node.context.values[ROOT_CONTEXT_NAME as any];},},},})
Const RoundNodeType
Round
NodeType: StatelessNodeType<"round", RoundNodeProperties> = createNodeType<'round',RoundNodeProperties>('round', {shape: {target: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target }: RoundNodeProperties): Array<NodeDependency> {return [{ target, until: untilNumberValueNode(RoundNodeType, 'target') }];},run(node: RoundNode, options: never, [target]: [ValueNode<number>]): NodeDefinition {return toValue(Math.round(target.definition.properties.value));},},},})
Const SCOPE
SCOPE: unique symbol = Symbol.for('muster::SCOPE')
Const ScopeNodeType
Scope
NodeType: StatefulNodeType<"scope", ScopeNodeProperties, ScopeNodeState, ScopeNodeData> = createNodeType<'scope', ScopeNodeProperties, ScopeNodeState, ScopeNodeData>('scope', {shape: {context: types.optional(types.objectOf(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),),root: graphTypes.nodeDefinition,redispatch: types.optional(types.oneOfType([types.saveHash(types.func), types.bool])),},state: {scope: types.optional(graphTypes.scope),context: types.optional(graphTypes.context),},getInitialState() {return {scope: undefined,context: undefined,};},onSubscribe(this: NodeExecutionContext<ScopeNodeState, ScopeNodeData>, node: ScopeNode): void {const { root, context, redispatch } = node.definition.properties;const childScope = createChildScope(node.scope, {redispatch,onSubscribe: () => this.retain(),onUnsubscribe: () => this.release(),});const childContext = createRootContext({...(context &&mapValues(context, (contextValue) =>isGraphNode(contextValue) ? contextValue : withScopeFrom(node, contextValue),)),[PARENT_SCOPE_PATH_KEY]: withScopeFrom(node, value(getPath(node.context))),});// TODO: Remove the `as any` cast once https://github.com/Microsoft/TypeScript/issues/1863 is resolvedchildContext.values[ROOT_CONTEXT_NAME as any] = createGraphNode(childScope, childContext, root);this.setState((prevState): ScopeNodeState => ({...prevState,scope: childScope,context: childContext,}),);const scopeDefinition = node.definition as ScopeNodeDefinition;scopeDefinition.activeScopes.push(childScope);},onUnsubscribe(this: NodeExecutionContext<ScopeNodeState, ScopeNodeData>, node: ScopeNode): void {const { scope } = this.getState();if (!scope) {return;}const scopeDefinition = node.definition as ScopeNodeDefinition;const scopeIndex = scopeDefinition.activeScopes.indexOf(scope);if (scopeIndex !== -1) {scopeDefinition.activeScopes.splice(scopeIndex, 1);}},operations: {evaluate: {run(node: ScopeNode,options: never,dependencies: Array<never>,contextDependencies: Array<never>,state: ScopeNodeState,): NodeDefinition | GraphNode {const { root } = node.definition.properties;const { scope, context } = state;return createGraphNode(scope!, context!, root);},},},})
Const SentenceCaseNodeType
Sentence
CaseNodeType: StatelessNodeType<"sentence-case", SentenceCaseNodeProperties> = createNodeType<'sentence-case', SentenceCaseNodeProperties>('sentence-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: SentenceCaseNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(SentenceCaseNodeType, 'subject'),},];},run(node: SentenceCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(upperFirst(subject.definition.properties.value));},},},})
Const SeriesNodeType
Series
NodeType: StatelessNodeType<"series", SeriesNodeProperties> = createNodeType<'series',SeriesNodeProperties>('series', {shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {cacheable: false,getDependencies({ operations }: SeriesNodeProperties): Array<NodeDependency> {return operations.length > 0 ? [{ target: operations[0], once: true }] : [];},run(node: SeriesNode, options: never, [result]: [GraphNode]): NodeDefinition {const operations = node.definition.properties.operations;if (operations.length === 0) return value(undefined);if (operations.length === 1) return once(result.definition);return series(operations.slice(1));},},},})
Const SetNodeType
Set
NodeType: StatelessNodeType<"set", SetNodeProperties> = createNodeType<'set',SetNodeProperties>('set', {shape: {target: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target }: SetNodeProperties): [NodeDependency] {return [{target,until: untilSupportsSetOperation,},];},run(node: SetNode, operation: never, [targetNode]: [SettableGraphNode]): GraphAction {const { value } = node.definition.properties;return createGraphAction(targetNode, setOperation(value));},},},})
Const SetOperationType
Set
OperationType: OperationType<"set", SetProperties> = createOperationType<'set',SetProperties>('set', {cacheable: false,shape: {value: graphTypes.nodeDefinition,},})
Const SetResultNodeType
Set
ResultNodeType: StatelessNodeType<"setResult", SetResultNodeProperties> = createNodeType<'setResult', SetResultNodeProperties>('setResult', {shape: {target: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target, value }: SetResultNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsSetOperation,},{target: value,},];},run(node: SetResultNode,operation: never,[targetNode, value]: [SettableGraphNode, GraphNode],): GraphAction {return createGraphAction(targetNode, setOperation(value.definition));},},},})
Const ShiftNodeType
Shift
NodeType: StatefulNodeType<"shift", ShiftNodeProperties, ShiftNodeState, __type> = createNodeType<'shift', ShiftNodeProperties, ShiftNodeState, {}>('shift', {shape: {id: types.number,target: graphTypes.nodeDefinition,},state: {currentValue: types.optional(graphTypes.nodeDefinition),},getInitialState() {return {currentValue: undefined,};},operations: {evaluate: {cacheable: false,run(node: ShiftNode,options: never,dependencies: never,context: never,state: ShiftNodeState,): GraphNode {return state.currentValue!;},onSubscribe(this: NodeExecutionContext<ShiftNodeState, {}>, node: ShiftNode): void {if (this.getState().currentValue) return;const { target } = node.definition.properties;this.setState(() => ({currentValue: withScopeFrom(node,resolve([{ target, until: untilSupportsShiftOperation }], ([resolvedTarget]) => {return withScopeFrom(resolvedTarget,resolve([createGraphAction(resolvedTarget, shiftOperation())], ([result]) => {this.setState(() => ({ currentValue: result }));return result;}),);}),),}));},},},})
Const ShiftOperationType
Shift
OperationType: OperationType<"shift", ShiftProperties> = createOperationType<'shift',ShiftProperties>('shift', {cacheable: false,shape: {},})
Const SkipNodeType
Skip
NodeType: StatelessNodeType<"skip", SkipNodeProperties> = createNodeType('skip', {shape: {offset: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ offset }: SkipNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},];},run(node: SkipNode,operation: TransformItemsOperation,[offset]: [ValueNode<number>],): NodeDefinition {const { value: offsetValue } = offset.definition.properties;return nodeList(operation.properties.items.slice(offsetValue));},},init: {run(node: SkipNode, operation: InitOperation): NodeDefinition {const { next } = operation.properties;if (!next) {return error('Skip reducer cannot be used as a base reducer');}return withReducerState(0, traverse(next, init()));},},step: {getDependencies({ offset }: SkipNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},];},run(node: SkipNode,operation: StepOperation<[any, number]>,[offset]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const { acc, item, next } = operation.properties;if (!next) {return error('Skip reducer cannot be used as a base reducer');}const [items, currentIndex] = acc;const { value: firstIndex } = offset.definition.properties;if (currentIndex < firstIndex) {return withReducerState(currentIndex + 1, value(items));}return withReducerState(currentIndex, traverse(next, step(items, item)));},},result: {run(node: SkipNode, operation: ResultOperation<[any, number]>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Skip reducer cannot be used as a base reducer');}const [items] = acc;return createGraphAction(next, result(items));},},},})
Const SliceNodeType
Slice
NodeType: StatelessNodeType<"slice", SliceNodeProperties> = createNodeType('slice',{shape: {offset: graphTypes.nodeDefinition,length: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ offset, length }: SliceNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},{target: length,until: untilPositiveIntegerLength,},];},run(node: SliceNode,operation: TransformItemsOperation,[offset, length]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const { items } = operation.properties;const { value: offsetValue } = offset.definition.properties;const { value: lengthValue } = length.definition.properties;return nodeList(items.slice(offsetValue, offsetValue + lengthValue));},},init: {run(node: SliceNode, operation: InitOperation): NodeDefinition {const { next } = operation.properties;if (!next) {return error('Slice reducer cannot be used as a base reducer');}return withReducerState(0, traverse(next, init()));},},step: {getDependencies({ offset, length }: SliceNodeProperties): Array<NodeDependency> {return [{target: offset,until: untilPositiveIntegerOffset,},{target: length,until: untilPositiveIntegerLength,},];},run(node: SliceNode,operation: StepOperation<[any, number]>,[offset, length]: [ValueNode<number>, ValueNode<number>],): NodeDefinition {const { acc, item, next } = operation.properties;if (!next) {return error('Slice reducer cannot be used as a base reducer');}const [items, currentIndex] = acc;const firstIndex = offset.definition.properties.value;const lastIndex = firstIndex + length.definition.properties.value - 1;if (currentIndex < firstIndex) {return withReducerState(currentIndex + 1, value(items));}if (currentIndex > lastIndex) {return done(withReducerState(currentIndex + 1, value(items)));}const nextValue = withReducerState(currentIndex + 1, traverse(next, step(items, item)));return currentIndex === lastIndex ? done(nextValue) : nextValue;},},result: {run(node: SliceNode,operation: ResultOperation<[any, number]>,): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Slice reducer cannot be used as a base reducer');}const [items] = acc;return createGraphAction(next, result(items));},},},},)
Const SortNodeType
Sort
NodeType: StatelessNodeType<"sort", SortNodeProperties> = createNodeType('sort', {shape: {order: types.arrayOf(graphTypes.nodeDefinition),},operations: {transformItems: {getDependencies({ order }: SortNodeProperties): Array<NodeDependency> {return order.map((item) => ({target: item,until: untilIsSortOrderNode,}));},run(node: SortNode,operation: TransformItemsOperation,orderNodes: Array<SortOrderNode>,): NodeDefinition {const { items } = operation.properties;const descending = orderNodes.map((orderNode) => orderNode.definition.properties.descending,);return resolve(flatMap(items, (item) =>orderNodes.map((order) => ({target: apply([item], order),until: untilIsValidSortValue,})),),(combinedSortValueNodes: Array<ValueNode<SortValue>>) => {const combinedSortValues = combinedSortValueNodes.map((node) => node.definition.properties.value,);const itemSortValues = chunk(combinedSortValues, orderNodes.length);const sortedItems = (zip<GraphNode | Array<SortValue>>(items, itemSortValues) as Array<[GraphNode, Array<SortValue>]>).sort(([item1, sortValues1], [item2, sortValues2]) =>compareSortValues(sortValues1, sortValues2, descending),).map(([item]) => item);return withScopeFrom(node, nodeList(sortedItems));},);},},init: {run(node: SortNode): NodeDefinition {const initialState = [] as Array<GraphNode>;return value(initialState);},},step: {run(node: SortNode, operation: StepOperation<Array<GraphNode>>): NodeDefinition {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {getDependencies({ order }: SortNodeProperties): Array<NodeDependency> {return order.map((iteratee) => ({target: iteratee,until: untilIsSortOrderNode,}));},run(node: SortNode,operation: ResultOperation<Array<GraphNode>>,orderNodes: Array<SortOrderNode>,): NodeDefinition {const { acc, next } = operation.properties;if (!next) {return error('Sort reducer cannot be used as a base reducer');}const descending = orderNodes.map((orderNode) => orderNode.definition.properties.descending,);const sortedItems = resolve(flatMap(acc, (item) =>orderNodes.map((order) => ({target: apply([item], order.definition.properties.iteratee),until: untilIsValueNode,})),),(orderResults: Array<ValueNode<SortValue>>) => {const itemsWithSortValues = acc.map((item, itemIndex) =>[item,orderNodes.map((order, orderIndex) =>orderResults[itemIndex * orderNodes.length + orderIndex].definition.properties.value,),] as [GraphNode, Array<SortValue>],);const sortedItems = itemsWithSortValues.sort(([, sortValues1], [, sortValues2]) => {return compareSortValues(sortValues1, sortValues2, descending);}).map(([item]) => item);return withScopeFrom(node, nodeList(sortedItems));},);return value(transduce(sortedItems, [next]));},},},})
Const SortOrderNodeType
Sort
OrderNodeType: StatelessNodeType<"sortOrder", SortOrderNodeProperties> = createNodeType('sortOrder', {shape: {iteratee: graphTypes.nodeDefinition,descending: types.bool,},operations: {call: {getDependencies({ iteratee }: SortOrderNodeProperties,operation: CallOperation,): Array<NodeDependency> {return [{target: apply(operation.properties.args!, iteratee),until: untilIsValidSortValue,},];},run(node: SortOrderNode, operation: CallOperation, [result]: [GraphNode]): GraphNode {return result;},},},})
Const SplitNodeType
Split
NodeType: StatelessNodeType<"split", SplitNodeProperties> = createNodeType<'split',SplitNodeProperties>('split', {shape: {limit: types.optional(graphTypes.nodeDefinition),separator: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ limit, separator, subject }: SplitNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(SplitNodeType, 'subject'),},{target: separator,until: untilStringValueNode(SplitNodeType, 'separator'),},...(limit? [{ target: limit, until: untilPositiveIntegerValueNode(SplitNodeType, 'limit') }]: []),];},run(node: SplitNode,options: never,[subject, separator, ...rest]: [ValueNode<string>, ValueNode<string>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const separatorValue = separator.definition.properties.value;const limitValue =rest.length === 1 ? (rest[0].definition.properties.value as number) : undefined;return array(subjectValue.split(separatorValue, limitValue).map(value));},},},})
Const SqrtNodeType
Sqrt
NodeType: StatelessNodeType<"sqrt", SqrtNodeProperties> = createNodeType<'sqrt',SqrtNodeProperties>('sqrt', {shape: {operand: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ operand }: SqrtNodeProperties): Array<NodeDependency> {return [{target: operand,until: untilNumberValueNode(SqrtNodeType, 'base'),},];},run(node: SqrtNode, options: never, [operand]: [ValueNode<number>]): NodeDefinition {return value(Math.sqrt(operand.definition.properties.value));},},},})
Const StartCaseNodeType
Start
CaseNodeType: StatelessNodeType<"start-case", StartCaseNodeProperties> = createNodeType<'start-case', StartCaseNodeProperties>('start-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: StartCaseNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(StartCaseNodeType, 'subject'),},];},run(node: StartCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(lodashStartCase(subject.definition.properties.value));},},},})
Const StartsWithNodeType
Starts
WithNodeType: StatelessNodeType<"starts-with", StartsWithNodeProperties> = createNodeType<'starts-with', StartsWithNodeProperties>('starts-with', {shape: {pattern: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ pattern, subject }: StartsWithNodeProperties): Array<NodeDependency> {return [{target: pattern,until: untilStringValueNode(StartsWithNodeType, 'pattern'),},{target: subject,acceptNil: true,until: untilStringValueNode(StartsWithNodeType, 'subject'),},];},run(node: StartsWithNode,options: never,[pattern, subject]: [ValueNode<string>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return value(false);const patternValue = pattern.definition.properties.value;const subjectValue = subject.definition.properties.value;return value((subjectValue || '').startsWith(patternValue));},},},})
Const StepOperationType
Step
OperationType: OperationType<"step", StepProperties<any>> = createOperationType<'step',StepProperties<any>>('step', {shape: {acc: types.optional(types.saveHash(types.any)),item: graphTypes.graphNode,next: types.optional(graphTypes.graphNode),},})
Const StringNodeTypes
String
NodeTypes: Array<NodeType> = [CharAtNodeType,EndsWithNodeType,FormatNodeType,FromBase64NodeType,IncludesNodeType,JoinNodeType,LowerCaseNodeType,MatchPatternNodeType,ParseFloatNodeType,ParseIntNodeType,RegexNodeType,ReplaceNodeType,SentenceCaseNodeType,SplitNodeType,StartCaseNodeType,StartsWithNodeType,SubstringNodeType,TestNodeType,ToBase64NodeType,ToStringNodeType,TrimNodeType,TruncateNodeType,UpperCaseNodeType,]
Const SubstringNodeType
Substring
NodeType: StatelessNodeType<"substring", SubstringNodeProperties> = createNodeType<'substring', SubstringNodeProperties>('substring', {shape: {endIndex: types.optional(graphTypes.nodeDefinition),startIndex: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({endIndex,startIndex,subject,}: SubstringNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(SubstringNodeType, 'subject'),},{target: startIndex,until: untilPositiveIntegerValueNode(SubstringNodeType, 'startIndex'),},...(endIndex? [{target: endIndex,until: untilPositiveIntegerValueNode(SubstringNodeType, 'endIndex'),},]: []),];},run(node: SubstringNode,options: never,[subject, startIndex, endIndex]: [ValueNode<string>, ValueNode<number>, ValueNode<number>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const startIndexValue = startIndex.definition.properties.value;const endIndexValue = endIndex ? endIndex.definition.properties.value : undefined;if (startIndexValue > subjectValue.length) return value('');return value(subjectValue.substring(startIndexValue, endIndexValue));},},},})
Const SubtractNodeType
Subtract
NodeType: StatelessNodeType<"subtract", SubtractNodeProperties> = createNodeType<'subtract', SubtractNodeProperties>('subtract', {shape: {operands: types.arrayOf(graphTypes.nodeDefinition),},operations: {evaluate: {getDependencies({ operands }: SubtractNodeProperties): Array<NodeDependency> {return operands.map((operand) => ({target: operand,until: untilNumberValueNode(SubtractNodeType, 'operand'),}));},run(node: SubtractNode, options: never, operands: Array<ValueNode<number>>): NodeDefinition {assertEnoughOperands(operands);const operandValues = operands.map((operand) => operand.definition.properties.value);return value(operandValues.reduce((total, value) => total - value));},},},})
Const SwitchOnNodeType
Switch
OnNodeType: StatelessNodeType<"switchOn", SwitchOnNodeProperties> = createNodeType<'switchOn', SwitchOnNodeProperties>('switchOn', {shape: {input: graphTypes.nodeDefinition,options: types.arrayOf(graphTypes.nodeDefinition),fallback: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ input, options }: SwitchOnNodeProperties): Array<NodeDependency> {return [{target: input,until: untilInputIsValueNode,},...options.map((option) => ({target: option.properties.pattern,until: untilPatternIsValueNodeOrCallableNode,})),];},run(node: SwitchOnNode,operation: never,dependencies: Array<ValueNode<any> | CallableGraphNode>,): NodeDefinition {const { options, fallback } = node.definition.properties;const [input] = dependencies as [ValueNode<any>];const [, ...resolvedOptions] = dependencies;return choose([...resolvedOptions.map((option, index) =>when(ValueNodeType.is(option)? eq(input.definition, option.definition): apply([input], option),options[index].properties.value,),),fallback,]);},},},})
Const TRANSACTION_END
TRANSACTION_END: "$$event:transactionEnd" = "$$event:transactionEnd"
Const TRANSACTION_START
TRANSACTION_START: "$$event:transactionStart" = "$$event:transactionStart"
Const TYPE_HASHERS
TYPE_
HASHERS: Map<Matcher<any, any> | function, HashFunction<any> | ValueHasherFactory<any, any>> = new Map<Matcher<any, any> | ((options: any) => Matcher<any, any>),HashFunction<any> | ValueHasherFactory<any, any>>([[types.empty, empty],[types.nil, nil],[types.bool, bool],[types.number, number],[types.integer, number],[types.string, string],[types.symbol, symbol],[types.date, date],[types.func, func],[types.object, object],[types.matcher, matcher],[types.instance, instance],[types.array, array],[types.instanceOf, instanceOf],[types.any, any],[types.oneOf, oneOf],[types.shape, shape],[types.arrayOf, arrayOf],[types.objectOf, objectOf],[types.oneOfType, oneOfType],[types.ignore, ignore],[types.optional, optional],[types.saveHash, saveHash],])
Const TakeLastNodeType
Take
LastNodeType: StatefulNodeType<"takeLast", TakeLastNodeProperties, TakeLastNodeState, TakeLastNodeData> = createNodeType<'takeLast', TakeLastNodeProperties, TakeLastNodeState, TakeLastNodeData>('takeLast',{state: {},shape: {operations: types.arrayOf(graphTypes.nodeDefinition),},getInitialState(): TakeLastNodeState {return {};},operations: {evaluate: {run(node: TakeLastNode): NodeDefinition {return last(node.definition.properties.operations) || nil();},onSubscribe(this: NodeExecutionContext<TakeLastNodeState, TakeLastNodeData>,node: TakeLastNode,): void {const { operations } = node.definition.properties;const subscriptions = operations.slice(0, -1).map((operation) =>node.scope.store.subscribe(withScopeFrom(node, operation), resolveOperation(), noop),);this.setData({unsubscribe: () => subscriptions.forEach((unsubscribe) => unsubscribe()),});},onUnsubscribe(this: NodeExecutionContext<TakeLastNodeState, TakeLastNodeData>): void {const { unsubscribe } = this.getData();if (unsubscribe) {unsubscribe();}},},},},)
Const TakeNodeType
Take
NodeType: StatelessNodeType<"take", TakeNodeProperties> = createNodeType('take', {shape: {numItems: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ numItems }: TakeNodeProperties): Array<NodeDependency> {return [{target: numItems,until: untilPositiveNumItemsNode,},];},run(node: TakeNode,operation: TransformItemsOperation,[numItems]: [ValueNode<number>],): NodeDefinition {const { value: numItemsValue } = numItems.definition.properties;return nodeList(operation.properties.items.slice(0, numItemsValue));},},init: {run(node: TakeNode, operation: InitOperation): NodeDefinition {const { next } = operation.properties;if (!next) {return error('Take reducer cannot be used as a base reducer');}return withReducerState(0, traverse(next, init()));},},step: {getDependencies({ numItems }: TakeNodeProperties): Array<NodeDependency> {return [{target: numItems,until: untilPositiveNumItemsNode,},];},run(node: TakeNode,operation: StepOperation<[any, number]>,[numItems]: [ValueNode<number>],): NodeDefinition {const { acc, item, next } = operation.properties;if (!next) {return error('Take reducer cannot be used as a base reducer');}const [items, currentIndex] = acc;const lastIndex = numItems.definition.properties.value - 1;if (currentIndex > lastIndex) {return done(value(acc));}const nextValue = withReducerState(currentIndex + 1, traverse(next, step(items, item)));return currentIndex === lastIndex ? done(nextValue) : nextValue;},},result: {run(node: TakeNode, operation: ResultOperation<[any, number]>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Take reducer cannot be used as a base reducer');}const [items] = acc;return createGraphAction(next, result(items));},},},})
Const TestNodeType
Test
NodeType: StatelessNodeType<"test", TestNodeProperties> = createNodeType<'test',TestNodeProperties>('test', {shape: {regex: graphTypes.nodeDefinition,subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ regex, subject }: TestNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(TestNodeType, 'subject'),},{target: regex,until: untilRegexNode(TestNodeType, 'regex'),},];},run(node: TestNode,options: never,[subject, regex]: [ValueNode<string>, RegexNode],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const regexValue = regex.definition.properties.pattern;return value(regexValue.test(subjectValue));},},},})
Const ToBase64NodeType
To
Base64NodeType: StatelessNodeType<"to-base64", ToBase64NodeProperties> = createNodeType<'to-base64', ToBase64NodeProperties>('to-base64', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: ToBase64NodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(ToBase64NodeType, 'subject'),},];},run(node: ToBase64Node, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(btoa(subject.definition.properties.value));},},},})
Const ToStringNodeType
To
StringNodeType: StatelessNodeType<"to-string", ToStringNodeProperties> = createNodeType<'to-string', ToStringNodeProperties>('to-string', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: ToStringNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilValueNode(ToStringNodeType, 'subject'),},];},run(node: ToStringNode, options: never, [subject]: [ValueNode<any>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();return value(lodashToString(subject.definition.properties.value));},},},})
Const TransduceNodeType
Transduce
NodeType: StatelessNodeType<"transduce", TransduceNodeProperties> = createNodeType<'transduce', TransduceNodeProperties>('transduce', {shape: {source: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),reducer: types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode]),},operations: {evaluate: {getDependencies({ reducer }: TransduceNodeProperties): Array<NodeDependency> {return [{target: traverse(reducer, init()),until: untilValidInitializer,},];},run(node: TransduceNode, options: never, [initialState]: [ValueNode<any>]): NodeDefinition {const { source, reducer } = node.definition.properties;return resolve([{target: reduce(source, reducer, initialState.definition.properties.value),until: untilValidStepResult,},],([acc]: [ValueNode<any>]) =>withScopeFrom(acc,resolve([{target: traverse(reducer, result(acc.definition.properties.value)),until: untilValidResult,},],([finalValue]: [ValueNode<any>]) => finalValue.definition.properties.value,),),);},},},})
Const TransformItemsOperationType
Transform
ItemsOperationType: OperationType<"transformItems", TransformItemsProperties> = createOperationType<'transformItems', TransformItemsProperties>('transformItems', {shape: {items: types.arrayOf(graphTypes.graphNode),},})
Const TransformResponseMiddlewareNodeType
Transform
ResponseMiddlewareNodeType: StatelessNodeType<"transform-response-middleware", TransformResponseMiddlewareNodeProperties> = createNodeType('transform-response-middleware', {shape: {responseTransformer: types.saveHash(types.func),},operations: {request: {run(node: TransformResponseMiddlewareNode, operation: RequestOperation): NodeDefinition {const { metadata, next, query } = operation.properties;if (!next) {return error('TransformResponseMiddleware cannot be used as a base middleware.');}const { responseTransformer } = node.definition.properties;return resolve([{target: withScopeFrom(next,traverse(next.definition, requestOperation(query, metadata)),),allowErrors: true,},],([response]) => withScopeFrom(response, responseTransformer(response.definition)),);},},},})
Const TransformsNodeTypes
Transforms
NodeTypes: Array<NodeType> = [CountNodeType,FilterNodeType,FirstItemNodeType,LastItemNodeType,MapNodeType,NthItemNodeType,SkipNodeType,SliceNodeType,SortNodeType,SortOrderNodeType,TakeNodeType,UniqueNodeType,]
Const TreeNodeType
Tree
NodeType: StatelessNodeType<"tree", TreeNodeProperties, SerializedTreeNodeProperties> = createNodeType<'tree', TreeNodeProperties, SerializedTreeNodeProperties>('tree', {shape: {branches: types.arrayOf(types.shape({match: types.saveHash(types.any),param: types.optional(types.string),node: graphTypes.nodeDefinition,}),),},operations: {getChild: {run(node: TreeNode, operation: GetChildOperation): NodeDefinition | GraphNode {const { key } = operation.properties;const branches = node.definition.properties.branches;const matchingBranch = findBranchByKey(branches, key);if (!matchingBranch) {return notFound(`Invalid child key: ${getType(key)}`);}const { param, node: child } = matchingBranch;const childContext = createChildPathContext(node,key,param === undefined? undefined: {[getParamContextId(param)]: withScopeFrom(node, value(key)),},);return createGraphNode(node.scope, childContext, child);},},},serialize<T>(properties: TreeNodeProperties,serialize: (value: any) => any,): SerializedTreeNodeProperties<T> {const { branches } = properties;return {branches: branches.map((b) => ({match: b.param === MISSING_PARAM_NAME ? undefined : serialize(b.match),param: b.param,node: serialize(b.node),})),};},deserialize<T>(data: SerializedTreeNodeProperties<T>,deserialize: (value: any) => any,): TreeNodeProperties {return {branches: data.branches.map((b) => {const deserializedNode = deserialize(b.node);if (b.param === MISSING_PARAM_NAME) {return { param: MISSING_PARAM_NAME, node: deserializedNode, match: types.any };}return { param: b.param, node: deserializedNode, match: deserialize(b.match) };}),};},getType(properties: TreeNodeProperties, getType: (value: any) => string): string {return `${TreeNodeType.name}({ ${(properties.branches as Array<any>).map((branch) =>`${typeof branch.match === 'string'? branch.match: branch.match.name? `[${branch.match.name}]`: '*'}: ${getType(branch.node)}`,).join(', ')} })`;},})
Const TrimNodeType
Trim
NodeType: StatelessNodeType<"trim", TrimNodeProperties> = createNodeType<'trim',TrimNodeProperties>('trim', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: TrimNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(TrimNodeType, 'subject'),},];},run(node: TrimNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;return value((subjectValue || '').trim());},},},})
Const TruncateNodeType
Truncate
NodeType: StatelessNodeType<"truncate", TruncateNodeProperties> = createNodeType<'truncate', TruncateNodeProperties>('truncate', {shape: {length: graphTypes.nodeDefinition,omission: types.optional(graphTypes.nodeDefinition),subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({length,omission,subject,}: TruncateNodeProperties): Array<NodeDependency> {return [{target: subject,acceptNil: true,until: untilStringValueNode(TruncateNodeType, 'subject'),},{target: length,until: untilPositiveIntegerValueNode(TruncateNodeType, 'length'),},...(omission? [{target: omission,until: untilStringValueNode(TruncateNodeType, 'omission'),},]: []),];},run(node: TruncateNode,options: never,[subject, length, omission]: [ValueNode<string>, ValueNode<number>, ValueNode<string>],): NodeDefinition {if (NilNodeType.is(subject)) return nil();const subjectValue = subject.definition.properties.value;const lengthValue = length.definition.properties.value;const omissionValue = omission ? omission.definition.properties.value : '…';return value(lodashTruncate(subjectValue, {length: lengthValue,omission: omissionValue,}),);},},},})
Const UniqueNodeType
Unique
NodeType: StatelessNodeType<"unique", UniqueNodeProperties> = createNodeType('unique',{shape: {predicate: graphTypes.nodeDefinition,},operations: {transformItems: {getDependencies({ predicate }: UniqueNodeProperties,operation: TransformItemsOperation,): Array<NodeDependency> {return operation.properties.items.map((item) => ({target: apply([item], predicate),until: untilIsValueNode,}));},run(node: UniqueNode,operation: TransformItemsOperation,uniqueResults: Array<ValueNode<any>>,): NodeDefinition {const { items } = operation.properties;const uniqueValues = uniqBy(uniqueResults.map((item, index) => [index, item] as [number, ValueNode<any>]),([index, item]) => valueOf(item),);return nodeList(uniqueValues.map(([index]) => items[index]));},},init: {run(node: UniqueNode, operation: InitOperation): NodeDefinition | GraphAction {const { next } = operation.properties;if (!next) {return error('Unique reducer cannot be used as a base reducer');}return createGraphAction(next, init());},},step: {run(node: UniqueNode, operation: StepOperation<Array<GraphNode>>): NodeDefinition {const { acc, item } = operation.properties;return value([...acc, item]);},},result: {run(node: UniqueNode, operation: ResultOperation<any>): NodeDefinition | GraphAction {const { acc, next } = operation.properties;if (!next) {return error('Unique reducer cannot be used as a base reducer');}const uniqueItems = resolve(acc.map((item: GraphNode) => ({target: apply([item], node.definition.properties.predicate),until: untilIsValueNode,})),(predicateResults: Array<ValueNode<any>>) => {const uniqueValues = uniqBy(predicateResults.map((item, index) => [index, item] as [number, ValueNode<any>]),([index, item]) => valueOf(item),);return nodeList(uniqueValues.map(([index]) => acc[index]));},);return value(transduce(uniqueItems, [next]));},},},},)
Const UnshiftNodeType
Unshift
NodeType: StatefulNodeType<"unshift", UnshiftNodeProperties, UnshiftNodeState, __type> = createNodeType<'unshift', UnshiftNodeProperties, UnshiftNodeState, {}>('unshift', {shape: {item: graphTypes.nodeDefinition,target: graphTypes.nodeDefinition,},state: {memoized: types.saveHash(types.func),},getInitialState() {return {memoized: once((target: GraphNode, item: NodeDefinition) =>createGraphAction(target, unshiftOperation(item)),),};},operations: {evaluate: {cacheable: false,getDependencies({ target }: UnshiftNodeProperties): Array<NodeDependency> {return [{target,until: untilSupportsUnshiftOperation,},];},run(node: UnshiftNode,options: never,[target]: [GraphNode],context: never,state: UnshiftNodeState,): GraphAction {return state.memoized(target, node.definition.properties.item);},},},})
Const UnshiftOperationType
Unshift
OperationType: OperationType<"unshift", UnshiftProperties> = createOperationType<'unshift', UnshiftProperties>('unshift', {cacheable: false,shape: {value: graphTypes.nodeDefinition,},})
Const UpdateNodeType
Update
NodeType: StatelessNodeType<"update", UpdateNodeProperties> = createNodeType<'update',UpdateNodeProperties>('update', {shape: {target: graphTypes.nodeDefinition,updater: graphTypes.nodeDefinition,},operations: {evaluate: {cacheable: false,getDependencies({ target, updater }: UpdateNodeProperties): [NodeDependency] {return [{target: call(updater, [target]),},];},run(node: UpdateNode, operation: never, [newValueNode]: [GraphNode]): NodeDefinition {return set(node.definition.properties.target, newValueNode.definition);},},},})
Const UpperCaseNodeType
Upper
CaseNodeType: StatelessNodeType<"upper-case", UpperCaseNodeProperties> = createNodeType<'upper-case', UpperCaseNodeProperties>('upper-case', {shape: {subject: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ subject }: UpperCaseNodeProperties): Array<NodeDependency> {return [{target: subject,until: untilStringValueNode(UpperCaseNodeType, 'subject'),},];},run(node: UpperCaseNode, options: never, [subject]: [ValueNode<string>]): NodeDefinition {return value(subject.definition.properties.value.toUpperCase());},},},})
Const ValueNodeType
Value
NodeType: StaticNodeType<"value", ValueNodeProperties<any>> = createNodeType<'value',ValueNodeProperties<any>>('value', {shape: {value: types.optional(types.saveHash(types.any)),},operations: {length: {run(node: ValueNode<any>): NodeDefinition {const { value: currentValue } = node.definition.properties;if (typeof currentValue === 'string') return value(currentValue.length);if (Array.isArray(currentValue)) return value(currentValue.length);return error('This value node does not support the length operation.');},},},})
Const VariableNodeType
Variable
NodeType: StatefulNodeType<"variable", VariableNodeProperties, VariableNodeState, VariableNodeData> = createNodeType<'variable', VariableNodeProperties, VariableNodeState, VariableNodeData>('variable',{state: {currentValue: types.optional(graphTypes.nodeDefinition),setResults: types.objectOf(graphTypes.nodeDefinition),},shape: {initialValue: graphTypes.nodeDefinition,validator: types.saveHash(types.matcher),},getInitialState(): VariableNodeState {return {currentValue: undefined,setResults: {},};},operations: {evaluate: {run(node: VariableNode,operation: never,dependencies: Array<never>,context: Array<never>,state: VariableNodeState,): NodeDefinition {const { currentValue } = state;return currentValue || node.definition.properties.initialValue;},},set: {run(node: VariableNode,operation: SetOperation,dependencies: never,context: never,state: VariableNodeState,): NodeDefinition {return state.setResults[operation.id];},onSubscribe(this: NodeExecutionContext<VariableNodeState, VariableNodeData>,node: VariableNode,operation: SetOperation,): void {const { currentValue: previousValue } = this.getState();const { validator } = node.definition.properties;const { value } = operation.properties;if (!previousValue) {this.retain();this.setData({disposeResetVariableListener: node.scope.events.listen((event) => {if (event.type !== EVENT_RESET_VARIABLE) return;resetVariableNode(this);}),});}// Check if the value is validif (isValueNodeDefinition(value) ? validator(valueOf(value)) : validator(value)) {// All is good in variable worldthis.setState((state) => ({...state,currentValue: value,setResults: {...state.setResults,[operation.id]: ok(),},}));} else {// Whoops, wrong value type!this.setState((state) => ({...state,setResults: {...state.setResults,[operation.id]: error(getInvalidTypeError('Could not set value of the variable node: value has an incorrect type.',{expected: `Value matched by ${getType(validator)}`,received: value,},),),},}));}},onUnsubscribe(this: NodeExecutionContext<VariableNodeState, VariableNodeData>,node: VariableNode,operation: SetOperation,): void {this.setState((state) => ({...state,setResults: omit(state.setResults, operation.id),}));},},reset: {run(node: VariableNode,options: never,dependencies: Array<never>,context: Array<never>,state: VariableNodeState,): NodeDefinition {return ok();},onSubscribe(this: NodeExecutionContext<VariableNodeState, VariableNodeData>,node: VariableNode,): void {resetVariableNode(this);},},},},)
Const WILDCARD_OPERATION
WILDCARD_OPERATION: "$$WILDCARD_OPERATION" = "$$WILDCARD_OPERATION"
Const WhenNodeType
When
NodeType: StaticNodeType<"when", WhenNodeProperties> = createNodeType<'when',WhenNodeProperties>('when', {shape: {pattern: graphTypes.nodeDefinition,value: graphTypes.nodeDefinition,},})
Const WithContextNodeType
With
ContextNodeType: StatelessNodeType<"withContext", WithContextNodeProperties> = createNodeType<'withContext', WithContextNodeProperties>('withContext', {shape: {values: types.objectOf(types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),),target: graphTypes.nodeDefinition,},operations: {evaluate: {run(node: WithContextNode): GraphNode {const { target, values } = node.definition.properties;const boundContextValues = fromPairs([...Object.getOwnPropertySymbols(values), ...Object.keys(values)].map((contextKey): [string | symbol, GraphNode] => {// TODO: Remove the `as any` cast once https://github.com/Microsoft/TypeScript/issues/1863 is resolvedconst value = values[contextKey as any];return [contextKey, isGraphNode(value) ? value : withScopeFrom(node, value)];},),);const childContext = createContext(node.context, boundContextValues);return createGraphNode(node.scope, childContext, target);},},},})
Const WithScopeNodeType
With
ScopeNodeType: StatelessNodeType<"withScope", WithScopeNodeProperties> = createNodeType<'withScope', WithScopeNodeProperties>('withScope', {shape: {target: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.nodeDefinition,graphTypes.graphNode,]),expression: graphTypes.nodeDefinition,},operations: {evaluate: {getDependencies({ target, expression }: WithScopeNodeProperties): [NodeDependency] {return [{ target }];},run(node: WithScopeNode, options: never, [subjectNode]: [GraphNode]): GraphNode {const { expression } = node.definition.properties;return withScopeFrom(subjectNode, expression);},},},})
Const WithTransformsNodeType
With
TransformsNodeType: StaticNodeType<"withTransforms", WithTransformsNodeProperties> = createNodeType<'withTransforms', WithTransformsNodeProperties>('withTransforms', {shape: {transforms: types.arrayOf(graphTypes.nodeDefinition),fields: graphTypes.nodeDefinition,},})
Const XhrMiddlewareNodeType
Xhr
MiddlewareNodeType: StatelessNodeType<"xhr-middleware", XhrMiddlewareNodeProperties> = createNodeType('xhr-middleware', {shape: {headers: types.optional(graphTypes.nodeDefinition),log: types.bool,nodeTypes: types.saveHash(types.any),numberOfRetries: types.number,operationTypes: types.saveHash(types.any),requestTimeout: types.number,retryDelay: types.number,url: types.string,withCredentials: types.bool,},operations: {request: {run(node: XhrMiddlewareNode, operation: RequestOperation): NodeDefinition | GraphNode {const { query } = operation.properties;const options = node.definition.properties;const processRequest = (headersNode?: NodeDefinition): GraphNode => {if (options.log) {console.log(`Request [${operation.id}] headers:`, getType(headersNode));}const headersObject = {Accept: 'application/json, text/plain, */*','Content-Type': 'application/json',...(getCustomHeaders(headersNode) || {}),};const requestStream = doHttpRequest({body: JSON.stringify(attachMetadata(sanitize(query))),headers: headersObject,numberOfRetries: options.numberOfRetries,retryDelay: options.retryDelay,requestTimeout: options.requestTimeout,url: options.url,withCredentials: options.withCredentials,});const responseStream = map((response) => deserializeResponse(options.nodeTypes, options.operationTypes, response),requestStream,);return withScopeFrom(node, fromStream(responseStream));};if (!options.headers) return processRequest();return resolve([{ target: options.headers, once: true }], ([resolvedHeaders]) =>processRequest(resolvedHeaders.definition),);},},},})
Const any
any
: Matcher<any, never> = createMatcher<any, never>('any', (value: any) => true)
Const array
array
: Matcher<any[], never> = createMatcher<Array<any>, never>('array', Array.isArray)
Const array
array
: HashFunction<any[]> = unique as HashFunction<Array<any>>
Const arrayOf
array
Of: ValueHasherFactory<Object[], Matcher<Object, any>> = (<T>() =>createHasherFactory('arrayOf',(matcher: Matcher<T, any>): HashFunction<Array<T>> => {const itemHasher = type(matcher);return (value: Array<T>): string => {let hash = 't(';// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < value.length; i++) {hash += `${itemHasher(value[i])}|`;}return `${hash})`;};},))()
Const bool
bool
: Matcher<boolean, never> = createMatcher<boolean, never>('bool',(value: any) => typeof value === 'boolean',)
Let cachedActionId
cachedActionId: number = 0
Const context
context
: HashFunction<Context> = hash.registerTypeHasher(graphTypes.context,(value: Context) => value.id,)
Const date
date
: Matcher<Date, never> = createMatcher<Date, never>('date', (value: any) =>Boolean(value && value.constructor === Date),)
Const empty
empty
: Matcher<undefined, never> = createMatcher<undefined, never>('empty',(value: any) => typeof value === 'undefined',)
Const es6TemplateStrings
es6TemplateStrings: any = require('es6-template-strings')
Const event
event
: HashFunction<MusterEvent> = hash.registerTypeHasher(graphTypes.event,(value: MusterEvent): string => `${hash.string(value.type)}:${hash.any(value.payload)}`,)
Const func
func
: HashFunction<Function> = unique as HashFunction<Function>
Const func
func
: Matcher<Function, never> = createMatcher<Function, never>('func',(value: any) => typeof value === 'function',)
Const global
global: Window & object
Const graphAction
graph
Action: HashFunction<GraphAction> = hash.registerTypeHasher(graphTypes.graphAction,(value: GraphAction): string => value.id,)
Const graphDeprecationWarning
graphDeprecationWarning: function = deprecated({old: 'graph',new: 'toNode',})
Const graphHash
graphHash: "/home/circleci/repo/packages/muster/src/utils/graph-hash" = _graphHash
Const graphNode
graph
Node: HashFunction<GraphNode> = hash.registerTypeHasher(graphTypes.graphNode,(value: GraphNode): string => value.id,)
Const graphOperation
graph
Operation: HashFunction<GraphOperation> = hash.registerTypeHasher(graphTypes.graphOperation,(value: GraphOperation): string => value.id,)
Const graphTypes
graphTypes: "/home/circleci/repo/packages/muster/src/utils/graph-types" = _graphTypes
Const hash
hash: "/home/circleci/repo/packages/muster/src/utils/hash" = _hash
Const hashContextValues
hash
ContextValues: HashFunction<object> = hashObjectOf(graphTypes.graphNode)
Const ignore
ignore
: Matcher<any, never> = createMatcher<any, never>('ignore', (value: any) => true)
Const instance
instance
: HashFunction<object> = unique as HashFunction<object>
Const instanceOf
instance
Of: HashFunction<object> = unique as HashFunction<object>
Const integer
integer
: Matcher<number, never> = createMatcher<number, never>('integer', Number.isInteger)
Const isPlainObject
isPlainObject: any = require('is-plain-object')
Const matcher
matcher
: Matcher<Matcher<any, any>, never> = createMatcher<Matcher<any, any>, never>('matcher', (value: any) =>isMatcher(value),)
Const migrator
migrator
: Migrator<NodeBefore, NodeAfter> = createMigrator<NodeBefore, NodeAfter>({[DEFAULT]: {downgrade(node, traverse): NodeBefore {return {$type: node.$type,data: traverse(node.data),};},upgrade(node, traverse): NodeAfter {return {$type: node.$type,data: traverse(node.data),};},},'inject-dependencies': {downgrade(node, traverse): NodeBefore {return {$type: 'partial',data: traverse(node.data),};},},items: {upgrade(node, traverse): NodeAfter {if (Array.isArray(node.data.transforms) && node.data.transforms.length > 0) {return {$type: 'withTransforms',data: {transforms: traverse(node.data.transforms),fields: {$type: 'entries',data: {children: traverse(node.data.children),},},},};}return {$type: 'entries',data: {children: traverse(node.data.children),},};},},entries: {downgrade(node, traverse): NodeBefore {return {$type: 'items',data: {transforms: undefined,children: traverse(node.data.children),},};},},withTransforms: {downgrade(node, traverse): NodeBefore {return {$type: 'items',data: {transforms: traverse(node.data.transforms),children: traverse((node.data.fields as NodeAfter).data.children),},};},},partial: {upgrade(node, traverse): NodeAfter {return {$type: 'inject-dependencies',data: traverse(node.data),};},},takeFirst: {upgrade(node, traverse): NodeAfter {return {$type: 'firstItem',data: traverse(node.data),};},},firstItem: {downgrade(node, traverse): NodeBefore {return {$type: 'takeFirst',data: traverse(node.data),};},upgrade(node, traverse): NodeAfter {return {$type: 'head',data: traverse(node.data),};},},head: {downgrade(node, traverse): NodeBefore {return {$type: 'firstItem',data: traverse(node.data),};},},takeLast: {upgrade(node, traverse): NodeAfter {return {$type: 'lastItem',data: traverse(node.data),};},},lastItem: {downgrade(node, traverse): NodeBefore {return {$type: 'takeLast',data: traverse(node.data),};},},takeNth: {upgrade(node, traverse): NodeAfter {return {$type: 'nthItem',data: traverse(node.data),};},},nthItem: {downgrade(node, traverse): NodeBefore {return {$type: 'takeNth',data: traverse(node.data),};},},sortOrder: {downgrade(node, traverse): NodeBefore {const { iteratee, descending } = traverse(node.data);return {$type: 'sortOrder',data: {descending,iteratee: {$type: 'fn',data: {argIds: [...iteratee.data.argIds, '$$dummyItemIndex'],body: iteratee.data.body,},},},};},upgrade(node, traverse): NodeAfter {const { iteratee, descending } = traverse(node.data);const [itemArg, itemIndexArg] = iteratee.data.argIds;return {$type: 'sortOrder',data: {descending,iteratee: {$type: 'fn',data: {argIds: [itemArg],body: replaceContextWithValue(iteratee.data.body, itemIndexArg, 0),hasNamedArgs: false,},},},};},},collection: {upgrade(node, traverse): NodeAfter {const { source, transforms } = traverse(node.data);if (transforms.length === 0) return source;return {$type: 'applyTransforms',data: {target: source,transforms,},};},},applyTransforms: {downgrade(node, traverse): NodeBefore {const { target, transforms } = traverse(node.data);return {$type: 'collection',data: {source: target,transforms,},};},},legacyQuery: {downgrade(node, traverse): NodeBefore {return {$type: 'query',data: traverse(node.data),};},},query: {upgrade(node, traverse): NodeAfter {return {$type: 'legacyQuery',data: traverse(node.data),};},},fn: {upgrade(node, traverse): NodeAfter {return {$type: 'fn',data: {argIds: traverse(node.data.argIds),body: traverse(node.data.body),hasNamedArgs: false,},};},downgrade(node, traverse): NodeBefore {return {$type: 'fn',data: {argIds: traverse(node.data.argIds),body: traverse(node.data.body),},};},},})
Const migrator
migrator
: Migrator<NodeBefore, NodeAfter> = createMigrator<NodeBefore, NodeAfter>({[DEFAULT]: {downgrade(node, traverse): NodeBefore {return {$type: node.$type,...mapValues(node.data, traverse),};},upgrade(node, traverse): NodeAfter {const keys = Object.keys(node).filter((k) => k !== '$type');return {$type: node.$type,data: keys.reduce((data: any, key: string) => {data[key] = traverse(node[key]);return data;}, {}),};},},apply: {upgrade(node, traverse): NodeAfter {return {$type: 'apply',data: {args: traverse(node.args),target: traverse(node.fn),},};},downgrade(node, traverse): NodeBefore {return {$type: 'apply',args: traverse(node.data.args),fn: traverse(node.data.target),};},},array: {upgrade(node, traverse): NodeAfter {return {$type: 'array',data: {items: traverse(node.nodes),},};},downgrade(node, traverse): NodeBefore {return {$type: 'array',nodes: traverse(node.data.items),};},},branch: {upgrade(node, traverse): NodeAfter {return {$type: 'tree',data: {branches: (node.branches || []).map((branch: any) => ({match: branch.match,node: traverse(branch.node),param: branch.name,})),},};},},context: {upgrade(node, traverse): NodeAfter {return {$type: 'context',data: {name: node.identifier,},};},downgrade(node, traverse): NodeBefore {return {$type: 'context',identifier: node.data.name,};},},decrement: {downgrade(node, traverse): NodeBefore {return {$type: 'subtract',operands: [traverse(node.data.operand), { $type: 'value', value: 1 }],};},},get: {upgrade(node, traverse): NodeAfter {// TODO: Handle the item placeholder (first, last, nth, ...)const key =node.childGetter.$type === 'key'? traverse(node.childGetter.key): traverse(node.childGetter); // TODO: Is this right?return {$type: 'get',data: {subject: traverse(node.subject),key,},};},downgrade(node, traverse): NodeBefore {// TODO: Handle the item placeholder (first, last, nth, ...)return {$type: 'get',childGetter: {$type: 'key',key: traverse(node.data.key),},subject: traverse(node.data.subject),};},},increment: {downgrade(node, traverse): NodeBefore {return {$type: 'add',operands: [traverse(node.data.operand), { $type: 'value', value: 1 }],};},},match: {upgrade(node, traverse): NodeAfter {return {$type: 'match-pattern',data: {regex: traverse(node.regex),subject: traverse(node.subject),},};},},'match-pattern': {downgrade(node, traverse): NodeBefore {return {$type: 'match',regex: traverse(node.data.regex),subject: traverse(node.data.subject),};},},multiple: {upgrade(node, traverse): NodeAfter {return {$type: 'parallel',data: {operations: (node.nodes || []).map(traverse),},};},},parallel: {downgrade(node, traverse): NodeBefore {return {$type: 'parallel',nodes: traverse(node.data.operations),};},upgrade(node, traverse): NodeAfter {return {$type: 'parallel',data: {operations: traverse(node.nodes),},};},},param: {upgrade(node, traverse): NodeAfter {return {$type: 'param',data: {name: node.id,},};},downgrade(node, traverse): NodeBefore {return {$type: 'param',id: node.data.name,};},},query: {upgrade(node, traverse): NodeAfter {return {$type: 'query',data: {root: traverse(node.root),keys: traverse(node.getters),},};},downgrade(node, traverse): NodeBefore {return {$type: 'query',root: traverse(node.data.root),getters: traverse(node.data.keys),};},},ref: {upgrade(node, traverse): NodeAfter {// TODO: Handle the item placeholder (first, last, nth, ...)const toNestedGet = (target: any, path: Array<any>): any => {const [key, ...remaining] = path;const get = {$type: 'get',data: {subject: target,key: traverse(key),},};if (remaining.length === 0) return get;return toNestedGet(get, remaining);};return toNestedGet(traverse(node.root), node.path);},},series: {upgrade(node, traverse): NodeAfter {return {$type: 'series',data: {operations: traverse(node.nodes),},};},downgrade(node, traverse): NodeBefore {return {$type: 'series',nodes: traverse(node.data.operations),};},},'sort-order': {upgrade(node, traverse): NodeAfter {return {$type: 'sortOrder',data: {descending: node.descending,iteratee: traverse(node.iteratee),},};},},sortOrder: {downgrade(node, traverse): NodeBefore {return {$type: 'sort-order',descending: node.data.descending,iteratee: traverse(node.data.iteratee),};},},'take-first': {upgrade(node, traverse): NodeAfter {return { $type: 'takeFirst', data: {} };},},takeFirst: {downgrade(node, traverse): NodeBefore {return { $type: 'take-first' };},},'take-last': {upgrade(node, traverse): NodeAfter {return { $type: 'takeLast', data: {} };},},takeLast: {downgrade(node, traverse): NodeBefore {return { $type: 'take-last' };},},'take-nth': {upgrade(node, traverse): NodeAfter {return {$type: 'takeNth',data: {index: traverse(node.index),},};},},takeNth: {downgrade(node, traverse): NodeBefore {return {$type: 'take-nth',index: traverse(node.data.index),};},},tree: {downgrade(node, traverse): NodeBefore {const branches = node.data.branches || [];const isSimpleTree = branches.every((branch: any) => !(branch.match || '').startsWith('$$match:'),);if (isSimpleTree) {return {$type: 'tree',branches: branches.reduce((tree: any, branch: any) => {if (branch.match) {tree[branch.match] = traverse(branch.node);}return tree;}, {}),};}return {$type: 'tree',branches: (node.data.branches || []).map((branch: any) => ({match: branch.match,name: branch.param,node: traverse(branch.node),})),};},upgrade(node, traverse): NodeAfter {return {$type: 'tree',data: {branches: toPairs(node.branches).map(([name, node]) => ({match: name,node: traverse(node),})),},};},},'with-context': {upgrade(node, traverse): NodeAfter {return {$type: 'withContext',data: {target: traverse(node.node),values: mapValues(node.context),},};},},withContext: {downgrade(node, traverse): NodeBefore {return {$type: 'with-context',node: traverse(node.data.target),context: mapValues(traverse),};},},})
Const musterVersion
musterVersion: any = require('@dws/muster-version')
Let nextPopId
nextPopId: number = 1
Let nextShiftId
nextShiftId: number = 1
Const nil
nil
: Matcher<null, never> = createMatcher<null, never>('nil', (value: any) => value === null)
Const nodeDefinition
node
Definition: HashFunction<NodeDefinition> = hash.registerTypeHasher(graphTypes.nodeDefinition,(value: NodeDefinition): string => value.id,)
Const nodeDependency
node
Dependency: Matcher<NodeDependency> = types.shape({allowErrors: types.optional(types.bool),allowPending: types.optional(types.bool),acceptNil: types.optional(types.bool),until: types.optional(types.shape({predicate: types.func,errorMessage: types.optional(types.func),}),),once: types.optional(types.bool),invalidate: types.optional(types.bool),target: types.oneOfType([nodeDefinition, graphNode]),})
Const nodeDependencyShapeHasher
Const nodeType
node
Type: HashFunction<NodeType> = hash.registerTypeHasher(graphTypes.nodeType,(value: NodeType) => value.name,)
Const nodeTypes
nodeTypes: Dictionary<object> = mapValues(getMusterNodeTypesMap(), (nodeType) => ({operations: Object.keys((nodeType as DynamicNodeType).operations || {}),}))
Const number
number
: Matcher<number, never> = createMatcher<number, never>('number',(value: any) => typeof value === 'number',)
Const object
object
: HashFunction<object> = unique as HashFunction<object>
Const object
object
: Matcher<object, never> = createMatcher<object, never>('object', (value: any) => isPlainObject(value))
Const objectOf
object
Of: ValueHasherFactory<object, Matcher<Object, any>> = (<T>() =>createHasherFactory('objectOf',(matcher: Matcher<T, any>,): HashFunction<{[key: string]: T;}> => {const valueHasher = type(matcher);return (value: { [key: string]: T }): string => {let hash = 'm(';const symbolKeys = Object.getOwnPropertySymbols(value);// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < symbolKeys.length; i++) {const key = symbolKeys[i];// TODO: Remove the `as any` cast once https://github.com/Microsoft/TypeScript/issues/1863 is resolvedhash += `${symbol(key)}=${valueHasher(value[key as any])}`;}const objectKeys = Object.keys(value).filter((key) => value.hasOwnProperty(key));// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < objectKeys.length; i++) {const key = objectKeys[i];hash += `${string(key)}=${valueHasher(value[key])}|`;}return `${hash})`;};},))()
Const objectToTreeDeprecationWarning
objectToTreeDeprecationWarning: function = deprecated({old: 'objectToTree',new: 'toNode',})
Const oneOf
one
Of: ValueHasherFactory<Object, Object[]> = (<T>() =>createHasherFactory('oneOf',(values: Array<T>): HashFunction<T> => {return (value: T): string => `p${values.indexOf(value)}`;},))()
Const oneOfType
one
OfType: ValueHasherFactory<Object, Matcher<Object, any>[]> = (<T>() =>createHasherFactory('oneOfType',(matchers: Array<Matcher<T, any>>): HashFunction<T> => {const matcherHasherPairs = matchers.map((matcher) => [matcher, type(matcher)] as [Matcher<T>, HashFunction<T>],);return (value: T): string => {// tslint:disable-next-line:no-increment-decrementfor (let index = 0; index < matcherHasherPairs.length; index++) {const [matcher, hasher] = matcherHasherPairs[index];if (matcher(value)) {return `${index}:${hasher(value)}`;}}return 'u';};},))()
Const operation
operation: operation & object = Object.assign(// tslint:disable-next-line:ter-prefer-arrow-callbackfunction operation(definition: MusterOperation): MusterOperation {return definition;},{only: (definition: MusterOperation): MusterOperation => {return {only: true,...operation(definition),};},skip: (definition: MusterOperation): MusterOperation => {return {skip: true,...operation(definition),};},},)
Const operationType
operation
Type: HashFunction<OperationType> = hash.registerTypeHasher(graphTypes.operationType,(value: OperationType) => value.name,)
Const optional
optional
: ValueHasherFactory<undefined | Object, Matcher<Object, any>> = (<T>() =>createHasherFactory('optional',(matcher: Matcher<T, any>): HashFunction<T | undefined> => {const typeHasher = type(matcher);return (value: T | undefined): string => {if (typeof value === 'undefined' || value === null) return 'u';return typeHasher(value);};},))()
Const proxiedNode
proxied
Node: HashFunction<ProxiedNode> = hash.registerTypeHasher(graphTypes.proxiedNode,(value: ProxiedNode): string => `P(${getProxiedNodeValue(value).id})`,)
Const registerJestMatchers
registerJestMatchers: (Anonymous function) = once(() => {const jestExpect = global.expect;global.expect = Object.assign((received: any) => {const matchers = jestExpect(received);matchers.toEqual = decorateMatcher(matchers.toEqual);matchers.toHaveBeenCalledWith = decorateMatcher(matchers.toHaveBeenCalledWith);matchers.toHaveBeenLastCalledWith = decorateMatcher(matchers.toHaveBeenLastCalledWith);return matchers;}, jestExpect);setUnitTestMatcher(isJestAsymetricMatcher);})
Const saveHash
save
Hash: ValueHasherFactory<Object, Matcher<Object, any>> = (<T>() =>createHasherFactory('saveHash',(matcher: Matcher<T, any>): HashFunction<T> => {const typeHasher = type(matcher);return (value: T): string => {if ((value as any)['$$hash']) return (value as any)['$$hash'];const hash = typeHasher(value);if ((typeof value === 'object' && value !== null) || typeof value === 'function') {Object.defineProperty(value, '$$hash', {value: hash,enumerable: false,configurable: true,});}return hash;};},))()
Const scope
scope
: HashFunction<Scope> = hash.registerTypeHasher(graphTypes.scope,(value: Scope) => value.id,)
Const shape
shape
: ValueHasherFactory<Object, object> = (<T extends { [key in keyof T]: T[key] }>() =>createHasherFactory('shape',(fields: ShapeFields<T>): HashFunction<T> => {const propHashers = Object.keys(fields).map((key) => ({key,hash: type((fields as any)[key]),}));return (value: T): string => {let hash = 's(';// tslint:disable-next-line:no-increment-decrementfor (let i = 0; i < propHashers.length; i++) {const propHasher = propHashers[i];hash += `${propHasher.hash((value as any)[propHasher.key])}|`;}return `${hash})`;};},))()
Const showCollectionDeprecationWarning
showCollectionDeprecationWarning: function = deprecated({old: 'collection',new: 'applyTransforms',})
Const showGetItemsDeprecationWarning
showGetItemsDeprecationWarning: function = deprecated({old: 'getItems',new: 'applyTransforms',})
Const showRefArrayDeprecationWarning
showRefArrayDeprecationWarning: function = deprecated({ old: 'ref([...])', new: 'ref(...)' })
Const showRelativeArrayDeprecationWarning
showRelativeArrayDeprecationWarning: function = deprecated({old: 'relative([...])',new: 'relative(...)',})
Const showStrlenDeprecationWarning
showStrlenDeprecationWarning: function = deprecated({old: 'strlen',new: 'length',})
Const stream
stream: "/home/circleci/repo/packages/muster/src/utils/stream" = _stream
Const string
string
: Matcher<string, never> = createMatcher<string, never>('string',(value: any) => typeof value === 'string',)
Const stringHash
stringHash: any = require('string-hash')
Const symbol
symbol
: HashFunction<symbol> = ((): HashFunction<symbol> => {const symbolToIdMap = new Map<symbol, string>();return (value: symbol) => {const symbolId = symbolToIdMap.get(value);if (symbolId) return symbolId;const newSymbolId = `$${symbolToIdMap.size}`;symbolToIdMap.set(value, newSymbolId);return newSymbolId;};})()
Const symbol
symbol
: Matcher<symbol, never> = createMatcher<symbol, never>('symbol',(value: any) => typeof value === 'symbol',)
Const treeToObjectDeprecationWarning
treeToObjectDeprecationWarning: function = deprecated({old: 'treeToObject',new: 'valueOf',})
Const types
types: "/home/circleci/repo/packages/muster/src/utils/types" = _types
Const unique
unique
: HashFunction<Object> = (<T>(): HashFunction<T> => {let uid = 0;// tslint:disable-next-line:no-increment-decrementreturn (value: T): string => `*${++uid}`;})()
Const untilBooleanValueNodeItem
Const untilBooleanValuePredicate
Const untilIntegerValueIndex
Const untilIsPositiveIntegerValueNode
Const untilPositiveIntegerLength
Const untilPositiveIntegerOffset
Const untilPositiveIntegerOffset
Const untilPositiveNumItemsNode
Const untilPositiveValueIndex
Const untilValidSeparator
Const version
version: any = require('@dws/muster-version')
Const xhr
xhr: any = require('xhr')
Object literals
Const DEFAULT_QUERY_SET_OPTIONS
DEFAULT_QUERY_SET_OPTIONS: object
bubbleErrorsToTop
bubbleErrorsToTop: false = false
Const RESOLVE_NODE_SHAPE
RESOLVE_NODE_SHAPE: object
combine
combine
: Matcher<undefined | Function, Matcher<Function, any>> = types.saveHash(types.func)
dependencies
dependencies
: Matcher<(NodeDependency | GraphAction<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>, StaticNodeType<string, object, object>, StatelessNodeType<string, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>)[], Matcher<NodeDependency | GraphAction<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>, StaticNodeType<string, object, object>, StatelessNodeType<string, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<string, object, any, object, object, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, any>> = types.arrayOf(types.oneOfType<NodeDependency | GraphAction>([types.shape({target: types.oneOfType<NodeDefinition | GraphNode>([graphTypes.graphNode,graphTypes.nodeDefinition,]),allowErrors: types.optional(types.bool),allowPending: types.optional(types.bool),acceptNil: types.optional(types.bool),once: types.optional(types.bool),until: types.optional(types.shape({predicate: types.saveHash(types.func),errorMessage: types.optional(types.oneOfType<string | Function>([types.string, types.saveHash(types.func)]),),}),),}),graphTypes.graphAction,]),)
Const ResolveNodeType
ResolveNodeType: object
__computed
__computed: true = true
deserialize
deserialize: false = false as false
name
name: "resolve" = "resolve"
serialize
serialize: false = false as false
shape
shape
: Matcher<Object, object> = types.shape(RESOLVE_NODE_SHAPE)
is
-
Parameters
Returns boolean
operations
operations: object
evaluate
evaluate: object
cacheable
cacheable: true = true
getContextDependencies
- getContextDependencies(): Array<never>
run
-
Parameters
-
-
options: never
-
dependencies: Array<GraphNode>
Const TRAVERSE_NODE_SHAPE
TRAVERSE_NODE_SHAPE: object
root
root
: Matcher<NodeDefinition<any, any, any, object, any, StaticNodeType<any, any, any> | StatelessNodeType<any, any, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<any, any, any, object, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, Matcher<NodeDefinition<any, any, any, object, any, StaticNodeType<any, any, any> | StatelessNodeType<any, any, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>> | StatefulNodeType<any, any, any, object, any, string, GraphOperation<string, object, object, OperationType<string, object, object>>>>, any>[]> = types.oneOfType([graphTypes.nodeDefinition, graphTypes.graphNode])
Const TraverseNodeType
TraverseNodeType: object
__computed
__computed: true = true
deserialize
deserialize: false = false as false
hash
hash
: HashFunction<Object> = hash.shape(TRAVERSE_NODE_SHAPE)
name
name: "traverse" = "traverse"
serialize
serialize: false = false as false
shape
shape
: Matcher<Object, object> = types.shape(TRAVERSE_NODE_SHAPE)
is
-
Parameters
Returns boolean
operations
operations: object
evaluate
evaluate: object
cacheable
cacheable: true = true
getContextDependencies
getContextDependencies: function = constant([])
Const base64Encoder
base64Encoder: object
decode
- decode(value: string): any
encode
- encode(value: any): string
-
Parameters
Returns string
Const identityEncoder
identityEncoder: object
decode
decode: identity = identity
encode
encode: identity = identity
Const isValidReducerStepResult
isValidReducerStepResult: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const jsonEncoder
jsonEncoder: object
decode
decode: parse = JSON.parse
encode
encode: stringify = JSON.stringify
Const shallow
shallow: object
Const untilConditionIsValueNode
untilConditionIsValueNode: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilDataNode
untilDataNode: object
errorMessage
-
Parameters
Returns string
Const untilInputIsValueNode
untilInputIsValueNode: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilIsArrayNodeOrPendingNode
untilIsArrayNodeOrPendingNode: object
errorMessage
-
Parameters
Returns string
Const untilIsCollectionOrFullyResolvedNode
untilIsCollectionOrFullyResolvedNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsContainerOrFullyResolvedNode
untilIsContainerOrFullyResolvedNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsDataNode
untilIsDataNode: object
errorMessage
-
Parameters
Returns string
Const untilIsFieldsNodeOrCollectionFieldsNode
untilIsFieldsNodeOrCollectionFieldsNode: object
errorMessage
-
Parameters
Returns string
Const untilIsFullyResolvedNode
untilIsFullyResolvedNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsFullyResolvedValueNode
untilIsFullyResolvedValueNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilIsSortOrderNode
untilIsSortOrderNode: object
predicate
predicate: function = SortOrderNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilIsValidIteratorResult
untilIsValidIteratorResult: object
errorMessage
-
Parameters
Returns string
Const untilIsValidSortValue
untilIsValidSortValue: object
errorMessage
-
Parameters
Returns string
Const untilIsValueNode
untilIsValueNode: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilIsValueNodeOrKeyNode
untilIsValueNodeOrKeyNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilItemWithId
untilItemWithId: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilNodeSupportedByGet
untilNodeSupportedByGet: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilPatternIsValueNodeOrCallableNode
untilPatternIsValueNodeOrCallableNode: object
errorMessage
-
Parameters
Returns string
Const untilPlaceholderOrItems
untilPlaceholderOrItems: object
predicate
-
Parameters
Returns boolean
Const untilSupportsAddItemAtOperation
untilSupportsAddItemAtOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsCallOperation
untilSupportsCallOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsCallOperation
untilSupportsCallOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsCallOperation
untilSupportsCallOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsClearOperation
untilSupportsClearOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetChildOperation
untilSupportsGetChildOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemOperation
untilSupportsGetItemOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemOperation
untilSupportsGetItemOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemsOperation
untilSupportsGetItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsGetItemsOperation
untilSupportsGetItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsIsUpdatingOperationOrStaticNode
untilSupportsIsUpdatingOperationOrStaticNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilSupportsIterateOperation
untilSupportsIterateOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsIterateOperation
untilSupportsIterateOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsPopOperation
untilSupportsPopOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsPushOperation
untilSupportsPushOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsRemoveItemAtOperation
untilSupportsRemoveItemAtOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsRemoveItemOperation
untilSupportsRemoveItemOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsRemoveItemsOperation
untilSupportsRemoveItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsSetOperation
untilSupportsSetOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsShiftOperation
untilSupportsShiftOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsStepOperation
untilSupportsStepOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsTransformItemsOperation
untilSupportsTransformItemsOperation: object
errorMessage
-
Parameters
Returns string
Const untilSupportsUnshiftOperation
untilSupportsUnshiftOperation: object
errorMessage
-
Parameters
Returns string
Const untilValidGetItemsResult
untilValidGetItemsResult: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilValidGetItemsResult
untilValidGetItemsResult: object
predicate
-
Parameters
Returns boolean
Const untilValidInitializer
untilValidInitializer: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidJoinOperand
untilValidJoinOperand: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Const untilValidPlaceholderResult
untilValidPlaceholderResult: object
predicate
-
Parameters
Returns boolean
Const untilValidReducerStep
untilValidReducerStep: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidResult
untilValidResult: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidStepResult
untilValidStepResult: object
predicate
predicate: function = ValueNodeType.is
Type declaration
-
-
Parameters
Returns boolean
errorMessage
-
Parameters
Returns string
Const untilValidTargetNode
untilValidTargetNode: object
errorMessage
-
Parameters
Returns string
predicate
-
Parameters
Returns boolean
Muster
A universal data layer for your components and services
Muster comes bundled with a number of NodeDefinitions split into following categories:
Installation
npm install --save @dws/muster @dws/muster-observableUsage
Creating basic muster application
import muster from '@dws/muster';const app = muster({ firstName: 'John', lastName: 'Doe', age: 43, });
This example creates a muster application containing three nodes:
firstName: value ='John'lastName: value ='Doe'age: value =43Accessing data from a muster graph
const app = muster({ firstName: 'John' });First let's create a simple muster instance with a graph containing a single leaf value
firstName. Now we have an instance of muster we can make queries against it:const firstName = await app.resolve(ref('firstName'));The Muster object exposes a
resolvemethod which can be used for running queries against muster. In this example we've used a ref. This node is used to locate and return a graph node based on its path in the graph. The path in the graph is defined by the hierarchy of branches that exist in the muster graph. In this example we have just one branch containing a single leaffirstName. You can find out more about paths and branches in the ref and tree documentation.app.resolvereturns an object implementing both Observable and Promise APIs. In this example we have retrieved the current value of thefirstNamenode with the use of the Promise API. Alternatively this can also be done with Observable by subscribing to the returned observable:const unsubscribe = app.resolve(ref('firstName')).subscribe((firstName) => { // Do something with the first name as it changes over time });By nature, muster tries to execute the code synchronously when it can, so the callback of the
subscribewill be called immediately with the latest value offirstName. In this examplefirstNameresolves to'John'string.Notice:
subscribehas one important advantage overawait. It responds to changes in the subscribed query over time. Consider an example where thefirstNameis a node whose value changes while the application is running.Promisewill emit the value as soon as it's available but won't cause your code to be re-run when the value of the subscribed node changes. On the other hand, Observable will re-emit a new value causing the subscriber (the function used to create the subscription) to be executed again with a new value.See variable, fromPromise and fromStream for more information about settable nodes.
Creating muster application with branches
import muster, { computed, ref } from '@dws/muster';const app = muster({ user: { firstName: 'John', lastName: 'Doe', fullName: computed([ ref('user', 'firstName'), ref('user', 'lastName'), ], (firstName, lastName) =>
<span class="hljs-subst">${firstName}</span> <span class="hljs-subst">${lastName}</span>), }, });This example creates a muster application where the graph has one branch
user(tree). That branch has three leaves:firstName: value ='John'lastname: value ='Doe'fullName: computed = A node which computes full name of the user based on the current value offirstNameandlastName.Note the
fullNamecomputed dependencies are defined using fully qualified path of the nodes in the graph. This could have been simplified with the use of a relative helper function:import muster, { computed, ref, relative } from '@dws/muster';const app = muster({ user: { firstName: 'John', lastName: 'Doe', fullName: computed([ ref(relative('firstName')), ref(relative('lastName')), ], (firstName, lastName) =>
<span class="hljs-subst">${firstName}</span> <span class="hljs-subst">${lastName}</span>), }, });The benefit of using relative instead of defining the full path is apparent when refactoring the application graph. Imagine a scenario when the
userbranch is to be renamed tocurrentUser. In this scenario, when the full path is used we'd have to change the name in three places: branch definitions and both references. It would be much simpler with the use of relative helper: we'd have to only rename the branch.You can find out more about relative helper on its documentation.
Lazy-evaluating values
import muster, { computed, ref } from '@dws/muster';let externalValue = 'initial';
const app = muster({ testComputed: computed([], () => { externalValue = 'updated'; return true; }), });
// externalValue === 'initial' const subscription = app.resolve(ref('testComputed'));
// externalValue === 'initial'
const unsubscribe = subscription.subscribe((testComputedValue) => { // externalValue === 'updated' // testComputedValue === true }); // externalValue === 'updated'
This example demonstrates the principle of lazy evaluation in muster. In muster the value of every node is evaluated only when a subscription is created to that node. Note how the value of
externalValuechanges in this example. Thanks to the synchronous code execution in muster theexternalValueis set to the new value before the first line of the subscriber callback as well as after the call to thesubscribemethod.Most of the Muster NodeDefinitions are synchronous, with exception of fromPromise, fromStream (depending on the type of stream used), action, proxy and remote.
Complex queries
import muster, { key, query, root } from '@dws/muster';const app = muster({ user: { firstName: 'Bob', lastName: 'Johnson', }, });
const userTree = await app.resolve(query(root(), { user: key('user', { firstName: key('firstName'), lastName: key('lastName'), }), })); // userTree is a JS object with all of the requested branches encoded in it: // { // user: { // firstName: 'Bob', // lastName: 'Johnson', // }, // }
In previous examples we've been requesting a single NodeDefinition at a time. In real world apps this would not be the most efficient or fastest way of writing code. For this reason Muster comes with a query which allows for building complex queries. These queries define the shape of their output data as well as the place from the graph this data is to be retrieved from. See the query documentation to learn more about queries.